Struct LichessApi 

pub struct LichessApi<HttpClient> {
    pub client: HttpClient,
    /* private fields */
}

Fields

client: HttpClient

Implementations

impl LichessApi<Client>

pub async fn get_profile(&self) -> Result<Profile>

pub async fn get_email_address(&self) -> Result<Email>

pub async fn get_preferences(&self) -> Result<UserPreferences>

pub async fn get_kid_mode_status(&self) -> Result<KidMode>

pub async fn set_kid_mode_status( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn get_timeline( &self, request: impl Into<GetRequest>, ) -> Result<Timeline>

impl LichessApi<Client>

pub async fn get_cloud_evaluation( &self, request: impl Into<GetRequest>, ) -> Result<Evaluation>

impl LichessApi<Client>

pub async fn get_current_arena_tournaments(&self) -> Result<ArenaTournaments>

pub async fn create_arena_tournament( &self, request: impl Into<PostRequest>, ) -> Result<ArenaTournamentFull>

pub async fn get_arena_tournament( &self, id: &str, query: GetQuery, ) -> Result<ArenaTournamentFull>

pub async fn update_arena_tournament( &self, id: &str, form: UpdateArenaTournamentForm, ) -> Result<ArenaTournamentFull>

pub async fn export_arena_tournament_games( &self, id: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<GameJson>>>

pub async fn join_arena_tournament( &self, id: &str, form: JoinArenaTournamentForm, ) -> Result<bool>

pub async fn get_arena_tournament_results( &self, id: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<ArenaResult>>>

pub async fn get_arena_tournament_team_standing( &self, request: impl Into<GetRequest>, ) -> Result<ArenaTeamStanding>

pub async fn terminate_arena_tournament( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn withdraw_from_arena_tournament( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn update_arena_team_battle( &self, id: &str, form: TeamBattleForm, ) -> Result<ArenaTournamentFull>

pub async fn get_arena_tournaments_created_by_user( &self, username: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<ArenaTournament>>>

pub async fn get_arena_tournaments_played_by_user( &self, username: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<ArenaTournamentPlayed>>>

impl LichessApi<Client>

pub async fn board_abort_game( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn board_berserk_game( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn board_stream_game_chat( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<Vec<ChatLine>>>>

pub async fn board_write_in_chat( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn board_claim_draw( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn board_claim_victory( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn board_handle_draw( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn board_make_move( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn board_resign_game( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn board_create_a_seek( &self, request: impl Into<PostRequest>, ) -> Result<impl StreamExt<Item = Result<Value>>>

pub async fn board_stream_incoming_events( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<Event>>>

pub async fn board_stream_board_state( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<Event>>>

pub async fn board_handle_takeback( &self, request: impl Into<PostRequest>, ) -> Result<bool>

impl LichessApi<Client>

pub async fn bot_abort_game( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn bot_stream_game_chat( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<ChatLine>>>

pub async fn bot_write_in_chat( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn bot_claim_draw( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn bot_claim_victory( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn bot_draw_game( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn bot_make_move( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn bot_get_online( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<OnlineBot>>>

pub async fn bot_resign_game( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn bot_stream_incoming_events( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<Event>>>

pub async fn bot_stream_board_state( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<Event>>>

pub async fn bot_handle_takeback( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn bot_upgrade_account( &self, request: impl Into<PostRequest>, ) -> Result<bool>

impl LichessApi<Client>

pub async fn export_broadcast_pgn( &self, broadcast_tournament_id: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<String>>>

pub async fn export_broadcast_round_pgn( &self, broadcast_round_id: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<String>>>

pub async fn stream_broadcast_group_pgn( &self, broadcast_group_id: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<String>>>

pub async fn stream_broadcast_round_pgn( &self, broadcast_round_id: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<String>>>

pub async fn stream_broadcast_tournament_pgn( &self, broadcast_tour_id: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<String>>>

pub async fn get_broadcast_round( &self, broadcast_tournament_slug: &str, broadcast_round_slug: &str, broadcast_round_id: &str, ) -> Result<BroadcastRound>

pub async fn get_my_broadcast_rounds( &self, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<BroadcastMyRound>>>

pub async fn get_broadcasts_by_user( &self, username: &str, query: GetQuery, ) -> Result<BroadcastByUserPaginator>

pub async fn get_official_broadcasts( &self, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<BroadcastWithRounds>>>

pub async fn search_broadcasts( &self, query: GetQuery, ) -> Result<BroadcastSearchPaginator>

pub async fn get_top_broadcasts(&self, query: GetQuery) -> Result<BroadcastTop>

pub async fn update_broadcast_tournament( &self, broadcast_tournament_id: &str, form: CreateBroadcastTournamentForm, ) -> Result<bool>

pub async fn create_broadcast_round( &self, broadcast_tournament_id: &str, form: BroadcastRoundForm, ) -> Result<BroadcastRoundNew>

pub async fn get_broadcast_player( &self, broadcast_tournament_id: &str, player_id: &str, ) -> Result<BroadcastPlayerEntryWithFideAndGames>

pub async fn get_broadcast_players( &self, request: impl Into<GetRequest>, ) -> Result<Vec<BroadcastPlayerEntry>>

pub async fn get_broadcast_team_standings( &self, request: impl Into<GetRequest>, ) -> Result<Vec<BroadcastTeamLeaderboardEntry>>

pub async fn get_broadcast_tournament( &self, request: impl Into<GetRequest>, ) -> Result<BroadcastWithRoundsAndFullGroup>

pub async fn create_broadcast_tournament( &self, form: CreateBroadcastTournamentForm, ) -> Result<BroadcastWithRounds>

pub async fn update_broadcast_round( &self, broadcast_round_id: &str, query: PostQuery, form: BroadcastRoundForm, ) -> Result<BroadcastRound>

pub async fn push_broadcast_round_pgn( &self, broadcast_round_id: &str, pgn: String, ) -> Result<BroadcastPgnPush>

pub async fn reset_broadcast_round( &self, request: impl Into<PostRequest>, ) -> Result<bool>

impl LichessApi<Client>

pub async fn get_bulk_pairings(&self) -> Result<Vec<BulkPairing>>

pub async fn create_bulk_pairing( &self, form: CreateBulkPairingForm, ) -> Result<BulkPairing>

pub async fn get_bulk_pairing( &self, request: impl Into<GetRequest>, ) -> Result<BulkPairing>

pub async fn cancel_bulk_pairing( &self, request: impl Into<DeleteRequest>, ) -> Result<bool>

pub async fn export_bulk_pairing_games( &self, id: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<GameJson>>>

pub async fn start_bulk_pairing_clocks( &self, request: impl Into<PostRequest>, ) -> Result<bool>

impl LichessApi<Client>

pub async fn list_challenges(&self) -> Result<Challenges>

pub async fn create_challenge( &self, request: impl Into<PostRequest>, ) -> Result<ChallengeJson>

pub async fn accept_challenge( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn decline_challenge( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn cancel_challenge( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn challenge_ai( &self, request: impl Into<PostRequest>, ) -> Result<Move>

pub async fn create_open_challenge( &self, request: impl Into<PostRequest>, ) -> Result<ChallengeOpenJson>

pub async fn start_clocks( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn add_time_to_opponent_clock( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn show_challenge( &self, request: impl Into<GetRequest>, ) -> Result<ChallengeJson>

pub async fn admin_challenge_tokens( &self, request: impl Into<PostRequest>, ) -> Result<AdminChallengeTokenResults>

impl LichessApi<Client>

pub async fn list_external_engines(&self) -> Result<Vec<ExternalEngine>>

pub async fn create_external_engine( &self, request: impl Into<PostRequest>, ) -> Result<ExternalEngine>

pub async fn get_external_engine( &self, request: impl Into<GetRequest>, ) -> Result<ExternalEngine>

pub async fn update_external_engine( &self, request: impl Into<PutRequest>, ) -> Result<ExternalEngine>

pub async fn delete_external_engine( &self, request: impl Into<DeleteRequest>, ) -> Result<bool>

pub async fn analyse_with_external_engine( &self, request: impl Into<PostRequest>, ) -> Result<impl StreamExt<Item = Result<AnalysisResponse>>>

This method currently returns a 503 error (Service Unavailable) from the Lichess API

pub async fn acquire_analysis_request( &self, request: impl Into<PostRequest>, ) -> Result<Option<AcquireAnalysisResponse>>

pub async fn submit_analysis( &self, request: impl Into<PostRequest>, ) -> Result<()>

impl LichessApi<Client>

pub async fn search_fide_player( &self, request: impl Into<GetRequest>, ) -> Result<Vec<Player>>

pub async fn get_fide_player( &self, request: impl Into<GetRequest>, ) -> Result<Player>

pub async fn get_fide_player_ratings( &self, request: impl Into<GetRequest>, ) -> Result<PlayerRatings>

impl LichessApi<Client>

pub async fn export_one_game( &self, request: impl Into<GetRequest>, ) -> Result<GameJson>

pub async fn export_ongoing_game( &self, request: impl Into<GetRequest>, ) -> Result<GameJson>

pub async fn export_games_of_user( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<GameJson>>>

pub async fn export_games_by_ids( &self, request: impl Into<PostRequest>, ) -> Result<impl StreamExt<Item = Result<GameJson>>>

pub async fn stream_games_of_users( &self, request: impl Into<PostRequest>, ) -> Result<impl StreamExt<Item = Result<GameStream>>>

pub async fn stream_games_by_ids( &self, request: impl Into<PostRequest>, ) -> Result<impl StreamExt<Item = Result<GameStream>>>

pub async fn add_game_ids_to_stream( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn get_my_ongoing_games( &self, request: impl Into<GetRequest>, ) -> Result<Games>

pub async fn stream_game_moves( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<Move>>>

pub async fn import_game( &self, request: impl Into<PostRequest>, ) -> Result<ImportData>

pub async fn export_bookmarked_games( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<GameJson>>>

pub async fn export_imported_games( &self, ) -> Result<impl StreamExt<Item = Result<String>>>

pub async fn get_game_chat( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<ChatLine>>>

pub async fn bookmark_game(&self, request: impl Into<PostRequest>) -> Result<()>

impl LichessApi<Client>

pub async fn send_message( &self, request: impl Into<PostRequest>, ) -> Result<bool>

impl LichessApi<Client>

pub async fn test_tokens( &self, request: impl Into<PostRequest>, ) -> Result<TestResults>

pub async fn revoke_token(&self) -> Result<()>

pub async fn obtain_access_token( &self, request: impl Into<PostRequest>, ) -> Result<AccessToken>

Exchange an authorization code for an access token.

This completes the flow started with crate::model::oauth::authorize::AuthorizationUrl. It is the one endpoint that takes no bearer token, since it is what produces one, so the client may be built with LichessApi::new(client, None).

impl LichessApi<Client>

pub async fn openings_masters( &self, request: impl Into<GetRequest>, ) -> Result<OpeningExplorerJson>

pub async fn openings_lichess( &self, request: impl Into<GetRequest>, ) -> Result<OpeningExplorerJson>

pub async fn openings_player( &self, request: impl Into<GetRequest>, ) -> Result<OpeningExplorerJson>

pub async fn openings_otb( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<String>>>

impl LichessApi<Client>

pub async fn get_daily_puzzle(&self) -> Result<Puzzle>

pub async fn get_puzzle(&self, request: impl Into<GetRequest>) -> Result<Puzzle>

pub async fn get_new_puzzle( &self, request: impl Into<GetRequest>, ) -> Result<Puzzle>

pub async fn get_puzzle_activity( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<Activity>>>

pub async fn get_puzzles_to_replay( &self, request: impl Into<GetRequest>, ) -> Result<Replay>

pub async fn get_puzzle_dashboard( &self, request: impl Into<GetRequest>, ) -> Result<Dashboard>

pub async fn get_puzzle_storm_dashboard( &self, request: impl Into<GetRequest>, ) -> Result<Dashboard>

pub async fn make_puzzle_race( &self, request: impl Into<PostRequest>, ) -> Result<Race>

pub async fn get_puzzle_batch( &self, request: impl Into<GetRequest>, ) -> Result<Select>

pub async fn solve_puzzle_batch( &self, request: impl Into<PostRequest>, ) -> Result<SolveResponse>

pub async fn get_puzzle_race_results( &self, request: impl Into<GetRequest>, ) -> Result<RaceResults>

impl LichessApi<Client>

pub async fn get_following( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<UserExtended>>>

pub async fn follow_user(&self, request: impl Into<PostRequest>) -> Result<bool>

pub async fn unfollow_user( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn block_user(&self, request: impl Into<PostRequest>) -> Result<bool>

pub async fn unblock_user( &self, request: impl Into<PostRequest>, ) -> Result<bool>

impl LichessApi<Client>

pub async fn get_current_simuls(&self) -> Result<Simuls>

impl LichessApi<Client>

pub async fn create_study( &self, form: CreateStudyForm, ) -> Result<CreateStudyResponse>

pub async fn import_pgn_into_study( &self, request: impl Into<PostRequest>, ) -> Result<StudyImportPgnChapters>

pub async fn export_study_chapter_pgn( &self, study_id: &str, chapter_id: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<String>>>

pub async fn export_study_pgn( &self, study_id: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<String>>>

pub async fn get_study_metadata( &self, request: impl Into<HeadRequest>, ) -> Result<()>

pub async fn update_study_chapter_tags( &self, study_id: &str, chapter_id: &str, form: UpdateChapterTagsForm, ) -> Result<()>

pub async fn update_study_chapter_moves( &self, study_id: &str, chapter_id: &str, form: UpdateChapterMovesForm, ) -> Result<()>

pub async fn export_user_studies_pgn( &self, username: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<String>>>

pub async fn list_user_studies( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<StudyMetadata>>>

pub async fn delete_study_chapter( &self, study_id: &str, chapter_id: &str, ) -> Result<()>

impl LichessApi<Client>

pub async fn create_swiss_tournament( &self, team_id: &str, form: CreateSwissTournamentForm, ) -> Result<SwissTournament>

pub async fn get_swiss_tournament( &self, request: impl Into<GetRequest>, ) -> Result<SwissTournament>

pub async fn update_swiss_tournament( &self, id: &str, form: UpdateSwissTournamentForm, ) -> Result<SwissTournament>

pub async fn export_swiss_tournament_games( &self, id: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<GameJson>>>

pub async fn join_swiss_tournament( &self, id: &str, form: JoinSwissTournamentForm, ) -> Result<bool>

pub async fn get_swiss_tournament_results( &self, id: &str, query: GetQuery, ) -> Result<impl StreamExt<Item = Result<SwissResult>>>

pub async fn schedule_next_swiss_round( &self, id: &str, form: ScheduleNextRoundForm, ) -> Result<()>

pub async fn terminate_swiss_tournament( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn withdraw_from_swiss_tournament( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn get_swiss_tournament_trf( &self, request: impl Into<GetRequest>, ) -> Result<String>

impl LichessApi<Client>

pub async fn lookup_antichess( &self, request: impl Into<GetRequest>, ) -> Result<TablebaseJson>

pub async fn lookup_atomic( &self, request: impl Into<GetRequest>, ) -> Result<TablebaseJson>

pub async fn lookup_standard( &self, request: impl Into<GetRequest>, ) -> Result<TablebaseJson>

impl LichessApi<Client>

pub async fn get_popular_teams( &self, request: impl Into<GetRequest>, ) -> Result<TeamPaginatorJson>

pub async fn search_teams( &self, request: impl Into<GetRequest>, ) -> Result<TeamPaginatorJson>

pub async fn get_teams_of_player( &self, request: impl Into<GetRequest>, ) -> Result<Vec<Team>>

pub async fn get_team(&self, request: impl Into<GetRequest>) -> Result<Team>

pub async fn get_team_members( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<TeamMember>>>

pub async fn get_team_arena_tournaments( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<ArenaTournament>>>

pub async fn get_team_swiss_tournaments( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<SwissTournament>>>

pub async fn get_team_join_requests( &self, request: impl Into<GetRequest>, ) -> Result<Vec<TeamRequestWithUser>>

pub async fn accept_team_join_request( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn decline_team_join_request( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn kick_team_member( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn join_team(&self, request: impl Into<PostRequest>) -> Result<bool>

pub async fn quit_team(&self, request: impl Into<PostRequest>) -> Result<bool>

pub async fn send_team_update( &self, request: impl Into<PostRequest>, ) -> Result<bool>

pub async fn get_team_updates( &self, request: impl Into<GetRequest>, ) -> Result<TeamUpdates>

pub async fn get_team_updates_of_team( &self, request: impl Into<GetRequest>, ) -> Result<TeamUpdatesOfTeam>

impl LichessApi<Client>

pub async fn tv_channels(&self) -> Result<Channels>

pub async fn tv_stream_current( &self, ) -> Result<impl StreamExt<Item = Result<Event>>>

pub async fn tv_stream_channel_current( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<Event>>>

pub async fn tv_channel_games( &self, request: impl Into<GetRequest>, ) -> Result<impl StreamExt<Item = Result<GameJson>>>

impl LichessApi<Client>

pub async fn get_all_top_10(&self) -> Result<Top10s>

pub async fn get_one_leaderboard( &self, request: impl Into<GetRequest>, ) -> Result<Leaderboard>

pub async fn get_public_user_data( &self, request: impl Into<GetRequest>, ) -> Result<UserExtended>

pub async fn get_status_of_users( &self, request: impl Into<GetRequest>, ) -> Result<Vec<User>>

pub async fn get_rating_history( &self, request: impl Into<GetRequest>, ) -> Result<RatingHistory>

pub async fn get_user_performance_statistics( &self, request: impl Into<GetRequest>, ) -> Result<PerfStat>

pub async fn get_users_by_id( &self, request: impl Into<PostRequest>, ) -> Result<Vec<User>>

pub async fn get_live_streamers(&self) -> Result<Vec<StreamingUser>>

pub async fn get_crosstable( &self, request: impl Into<GetRequest>, ) -> Result<Crosstable>

pub async fn autocomplete_users( &self, request: impl Into<GetRequest>, ) -> Result<Autocompletions>

pub async fn add_note_to_user( &self, request: impl Into<PostRequest>, ) -> Result<Ok>

pub async fn get_user_notes( &self, request: impl Into<GetRequest>, ) -> Result<Vec<UserNote>>

pub async fn get_user_activity( &self, request: impl Into<GetRequest>, ) -> Result<Vec<UserActivity>>

impl LichessApi<Client>

pub async fn get_ok<Q, B>(&self, request: Request<Q, B>) -> Result<bool>

where Q: QueryBounds, B: BodyBounds,

pub async fn get_pgn<Q, B>( &self, request: Request<Q, B>, ) -> Result<impl StreamExt<Item = Result<String>>>

where Q: QueryBounds, B: BodyBounds,

pub async fn get_text<Q, B>(&self, request: Request<Q, B>) -> Result<String>

where Q: QueryBounds, B: BodyBounds,

pub async fn get_empty<Q, B>(&self, request: Request<Q, B>) -> Result<()>

where Q: QueryBounds, B: BodyBounds,

pub async fn get_single_model<Q, B, M>( &self, request: Request<Q, B>, ) -> Result<M>

where Q: QueryBounds, B: BodyBounds, M: ModelBounds,

pub async fn get_streamed_models<Q, B, M>( &self, request: Request<Q, B>, ) -> Result<impl StreamExt<Item = Result<M>>>

where Q: QueryBounds, B: BodyBounds, M: ModelBounds,

impl<HttpClient> LichessApi<HttpClient>

pub fn new(client: HttpClient, auth_token: Option<String>) -> Self

Trait Implementations

impl<HttpClient: Clone> Clone for LichessApi<HttpClient>

fn clone(&self) -> LichessApi<HttpClient>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<HttpClient: Debug> Debug for LichessApi<HttpClient>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.