#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(clippy::let_and_return, clippy::too_many_arguments)]
use crate::models::*;
use std::future::Future;
use std::vec::Vec;
#[cfg(feature="tracing")]
use tracing::Instrument;
use reqwest::Method;
use crate::Result;
use crate::consts::{ RegionalRoute, PlatformRoute, ValPlatformRoute };
use crate::riot_api::RiotApi;
impl RiotApi {
#[inline]
pub fn account_v1(&self) -> AccountV1 {
AccountV1 { base: self }
}
#[inline]
pub fn champion_mastery_v4(&self) -> ChampionMasteryV4 {
ChampionMasteryV4 { base: self }
}
#[inline]
pub fn champion_v3(&self) -> ChampionV3 {
ChampionV3 { base: self }
}
#[inline]
pub fn clash_v1(&self) -> ClashV1 {
ClashV1 { base: self }
}
#[inline]
pub fn league_exp_v4(&self) -> LeagueExpV4 {
LeagueExpV4 { base: self }
}
#[inline]
pub fn league_v4(&self) -> LeagueV4 {
LeagueV4 { base: self }
}
#[inline]
pub fn lol_challenges_v1(&self) -> LolChallengesV1 {
LolChallengesV1 { base: self }
}
#[inline]
pub fn lol_status_v3(&self) -> LolStatusV3 {
LolStatusV3 { base: self }
}
#[inline]
pub fn lol_status_v4(&self) -> LolStatusV4 {
LolStatusV4 { base: self }
}
#[inline]
pub fn lor_deck_v1(&self) -> LorDeckV1 {
LorDeckV1 { base: self }
}
#[inline]
pub fn lor_inventory_v1(&self) -> LorInventoryV1 {
LorInventoryV1 { base: self }
}
#[inline]
pub fn lor_match_v1(&self) -> LorMatchV1 {
LorMatchV1 { base: self }
}
#[inline]
pub fn lor_ranked_v1(&self) -> LorRankedV1 {
LorRankedV1 { base: self }
}
#[inline]
pub fn lor_status_v1(&self) -> LorStatusV1 {
LorStatusV1 { base: self }
}
#[inline]
pub fn match_v5(&self) -> MatchV5 {
MatchV5 { base: self }
}
#[inline]
pub fn spectator_tft_v5(&self) -> SpectatorTftV5 {
SpectatorTftV5 { base: self }
}
#[inline]
pub fn spectator_v4(&self) -> SpectatorV4 {
SpectatorV4 { base: self }
}
#[inline]
pub fn spectator_v5(&self) -> SpectatorV5 {
SpectatorV5 { base: self }
}
#[inline]
pub fn summoner_v4(&self) -> SummonerV4 {
SummonerV4 { base: self }
}
#[inline]
pub fn tft_league_v1(&self) -> TftLeagueV1 {
TftLeagueV1 { base: self }
}
#[inline]
pub fn tft_match_v1(&self) -> TftMatchV1 {
TftMatchV1 { base: self }
}
#[inline]
pub fn tft_status_v1(&self) -> TftStatusV1 {
TftStatusV1 { base: self }
}
#[inline]
pub fn tft_summoner_v1(&self) -> TftSummonerV1 {
TftSummonerV1 { base: self }
}
#[inline]
pub fn tournament_stub_v5(&self) -> TournamentStubV5 {
TournamentStubV5 { base: self }
}
#[inline]
pub fn tournament_v5(&self) -> TournamentV5 {
TournamentV5 { base: self }
}
#[inline]
pub fn val_content_v1(&self) -> ValContentV1 {
ValContentV1 { base: self }
}
#[inline]
pub fn val_match_v1(&self) -> ValMatchV1 {
ValMatchV1 { base: self }
}
#[inline]
pub fn val_ranked_v1(&self) -> ValRankedV1 {
ValRankedV1 { base: self }
}
#[inline]
pub fn val_status_v1(&self) -> ValStatusV1 {
ValStatusV1 { base: self }
}
}
#[repr(transparent)]
pub struct AccountV1<'a> {
base: &'a RiotApi,
}
impl<'a> AccountV1<'a> {
pub fn get_by_puuid(&self, route: RegionalRoute, puuid: &str)
-> impl Future<Output = Result<account_v1::Account>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/riot/account/v1/accounts/by-puuid/{}", puuid));
let future = self.base.execute_val::<account_v1::Account>("account-v1.getByPuuid", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("account-v1.getByPuuid"));
future
}
pub fn get_by_riot_id(&self, route: RegionalRoute, game_name: &str, tag_line: &str)
-> impl Future<Output = Result<Option<account_v1::Account>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/riot/account/v1/accounts/by-riot-id/{}/{}", game_name, tag_line));
let future = self.base.execute_opt::<account_v1::Account>("account-v1.getByRiotId", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("account-v1.getByRiotId"));
future
}
pub fn get_by_access_token(&self, route: RegionalRoute, authorization: &str)
-> impl Future<Output = Result<account_v1::Account>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/riot/account/v1/accounts/me");
let request = request.header("Authorization", authorization);
let future = self.base.execute_val::<account_v1::Account>("account-v1.getByAccessToken", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("account-v1.getByAccessToken"));
future
}
pub fn get_active_shard(&self, route: RegionalRoute, game: &str, puuid: &str)
-> impl Future<Output = Result<Option<account_v1::ActiveShard>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/riot/account/v1/active-shards/by-game/{}/by-puuid/{}", game, puuid));
let future = self.base.execute_opt::<account_v1::ActiveShard>("account-v1.getActiveShard", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("account-v1.getActiveShard"));
future
}
}
#[repr(transparent)]
pub struct ChampionMasteryV4<'a> {
base: &'a RiotApi,
}
impl<'a> ChampionMasteryV4<'a> {
pub fn get_all_champion_masteries_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str)
-> impl Future<Output = Result<Vec<champion_mastery_v4::ChampionMastery>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/champion-mastery/v4/champion-masteries/by-puuid/{}", encrypted_puuid));
let future = self.base.execute_val::<Vec<champion_mastery_v4::ChampionMastery>>("champion-mastery-v4.getAllChampionMasteriesByPUUID", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("champion-mastery-v4.getAllChampionMasteriesByPUUID"));
future
}
pub fn get_champion_mastery_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str, champion_id: crate::consts::Champion)
-> impl Future<Output = Result<champion_mastery_v4::ChampionMastery>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/champion-mastery/v4/champion-masteries/by-puuid/{}/by-champion/{}", encrypted_puuid, champion_id));
let future = self.base.execute_val::<champion_mastery_v4::ChampionMastery>("champion-mastery-v4.getChampionMasteryByPUUID", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("champion-mastery-v4.getChampionMasteryByPUUID"));
future
}
pub fn get_top_champion_masteries_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str, count: Option<i32>)
-> impl Future<Output = Result<Vec<champion_mastery_v4::ChampionMastery>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/champion-mastery/v4/champion-masteries/by-puuid/{}/top", encrypted_puuid));
let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
let future = self.base.execute_val::<Vec<champion_mastery_v4::ChampionMastery>>("champion-mastery-v4.getTopChampionMasteriesByPUUID", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("champion-mastery-v4.getTopChampionMasteriesByPUUID"));
future
}
pub fn get_champion_mastery_score_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str)
-> impl Future<Output = Result<i32>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/champion-mastery/v4/scores/by-puuid/{}", encrypted_puuid));
let future = self.base.execute_val::<i32>("champion-mastery-v4.getChampionMasteryScoreByPUUID", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("champion-mastery-v4.getChampionMasteryScoreByPUUID"));
future
}
}
#[repr(transparent)]
pub struct ChampionV3<'a> {
base: &'a RiotApi,
}
impl<'a> ChampionV3<'a> {
pub fn get_champion_info(&self, route: PlatformRoute)
-> impl Future<Output = Result<champion_v3::ChampionInfo>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/lol/platform/v3/champion-rotations");
let future = self.base.execute_val::<champion_v3::ChampionInfo>("champion-v3.getChampionInfo", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("champion-v3.getChampionInfo"));
future
}
}
#[repr(transparent)]
pub struct ClashV1<'a> {
base: &'a RiotApi,
}
impl<'a> ClashV1<'a> {
pub fn get_players_by_summoner(&self, route: PlatformRoute, summoner_id: &str)
-> impl Future<Output = Result<Vec<clash_v1::Player>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/clash/v1/players/by-summoner/{}", summoner_id));
let future = self.base.execute_val::<Vec<clash_v1::Player>>("clash-v1.getPlayersBySummoner", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("clash-v1.getPlayersBySummoner"));
future
}
pub fn get_team_by_id(&self, route: PlatformRoute, team_id: &str)
-> impl Future<Output = Result<Option<clash_v1::Team>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/clash/v1/teams/{}", team_id));
let future = self.base.execute_opt::<clash_v1::Team>("clash-v1.getTeamById", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("clash-v1.getTeamById"));
future
}
pub fn get_tournaments(&self, route: PlatformRoute)
-> impl Future<Output = Result<Vec<clash_v1::Tournament>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/lol/clash/v1/tournaments");
let future = self.base.execute_val::<Vec<clash_v1::Tournament>>("clash-v1.getTournaments", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("clash-v1.getTournaments"));
future
}
pub fn get_tournament_by_team(&self, route: PlatformRoute, team_id: &str)
-> impl Future<Output = Result<Option<clash_v1::Tournament>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/clash/v1/tournaments/by-team/{}", team_id));
let future = self.base.execute_opt::<clash_v1::Tournament>("clash-v1.getTournamentByTeam", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("clash-v1.getTournamentByTeam"));
future
}
pub fn get_tournament_by_id(&self, route: PlatformRoute, tournament_id: i32)
-> impl Future<Output = Result<Option<clash_v1::Tournament>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/clash/v1/tournaments/{}", tournament_id));
let future = self.base.execute_opt::<clash_v1::Tournament>("clash-v1.getTournamentById", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("clash-v1.getTournamentById"));
future
}
}
#[repr(transparent)]
pub struct LeagueExpV4<'a> {
base: &'a RiotApi,
}
impl<'a> LeagueExpV4<'a> {
pub fn get_league_entries(&self, route: PlatformRoute, queue: crate::consts::QueueType, tier: crate::consts::Tier, division: crate::consts::Division, page: Option<i32>)
-> impl Future<Output = Result<Vec<league_exp_v4::LeagueEntry>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/league-exp/v4/entries/{}/{}/{}", queue, tier, division));
let request = if let Some(page) = page { request.query(&[ ("page", page) ]) } else { request };
let future = self.base.execute_val::<Vec<league_exp_v4::LeagueEntry>>("league-exp-v4.getLeagueEntries", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("league-exp-v4.getLeagueEntries"));
future
}
}
#[repr(transparent)]
pub struct LeagueV4<'a> {
base: &'a RiotApi,
}
impl<'a> LeagueV4<'a> {
pub fn get_challenger_league(&self, route: PlatformRoute, queue: crate::consts::QueueType)
-> impl Future<Output = Result<league_v4::LeagueList>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/challengerleagues/by-queue/{}", queue));
let future = self.base.execute_val::<league_v4::LeagueList>("league-v4.getChallengerLeague", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("league-v4.getChallengerLeague"));
future
}
pub fn get_league_entries_for_summoner(&self, route: PlatformRoute, encrypted_summoner_id: &str)
-> impl Future<Output = Result<Vec<league_v4::LeagueEntry>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/entries/by-summoner/{}", encrypted_summoner_id));
let future = self.base.execute_val::<Vec<league_v4::LeagueEntry>>("league-v4.getLeagueEntriesForSummoner", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("league-v4.getLeagueEntriesForSummoner"));
future
}
pub fn get_league_entries(&self, route: PlatformRoute, queue: crate::consts::QueueType, tier: crate::consts::Tier, division: crate::consts::Division, page: Option<i32>)
-> impl Future<Output = Result<Vec<league_v4::LeagueEntry>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/entries/{}/{}/{}", queue, tier, division));
let request = if let Some(page) = page { request.query(&[ ("page", page) ]) } else { request };
let future = self.base.execute_val::<Vec<league_v4::LeagueEntry>>("league-v4.getLeagueEntries", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("league-v4.getLeagueEntries"));
future
}
pub fn get_grandmaster_league(&self, route: PlatformRoute, queue: crate::consts::QueueType)
-> impl Future<Output = Result<league_v4::LeagueList>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/grandmasterleagues/by-queue/{}", queue));
let future = self.base.execute_val::<league_v4::LeagueList>("league-v4.getGrandmasterLeague", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("league-v4.getGrandmasterLeague"));
future
}
pub fn get_league_by_id(&self, route: PlatformRoute, league_id: &str)
-> impl Future<Output = Result<Option<league_v4::LeagueList>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/leagues/{}", league_id));
let future = self.base.execute_opt::<league_v4::LeagueList>("league-v4.getLeagueById", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("league-v4.getLeagueById"));
future
}
pub fn get_master_league(&self, route: PlatformRoute, queue: crate::consts::QueueType)
-> impl Future<Output = Result<league_v4::LeagueList>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/masterleagues/by-queue/{}", queue));
let future = self.base.execute_val::<league_v4::LeagueList>("league-v4.getMasterLeague", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("league-v4.getMasterLeague"));
future
}
}
#[repr(transparent)]
pub struct LolChallengesV1<'a> {
base: &'a RiotApi,
}
impl<'a> LolChallengesV1<'a> {
pub fn get_all_challenge_configs(&self, route: PlatformRoute)
-> impl Future<Output = Result<Vec<lol_challenges_v1::ChallengeConfigInfo>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/lol/challenges/v1/challenges/config");
let future = self.base.execute_val::<Vec<lol_challenges_v1::ChallengeConfigInfo>>("lol-challenges-v1.getAllChallengeConfigs", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lol-challenges-v1.getAllChallengeConfigs"));
future
}
pub fn get_all_challenge_percentiles(&self, route: PlatformRoute)
-> impl Future<Output = Result<std::collections::HashMap<i64, std::collections::HashMap<crate::consts::Tier, f64>>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/lol/challenges/v1/challenges/percentiles");
let future = self.base.execute_val::<std::collections::HashMap<i64, std::collections::HashMap<crate::consts::Tier, f64>>>("lol-challenges-v1.getAllChallengePercentiles", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lol-challenges-v1.getAllChallengePercentiles"));
future
}
pub fn get_challenge_configs(&self, route: PlatformRoute, challenge_id: i64)
-> impl Future<Output = Result<Option<lol_challenges_v1::ChallengeConfigInfo>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/challenges/v1/challenges/{}/config", challenge_id));
let future = self.base.execute_opt::<lol_challenges_v1::ChallengeConfigInfo>("lol-challenges-v1.getChallengeConfigs", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lol-challenges-v1.getChallengeConfigs"));
future
}
pub fn get_challenge_leaderboards(&self, route: PlatformRoute, challenge_id: i64, level: crate::consts::Tier, limit: Option<i32>)
-> impl Future<Output = Result<Option<Vec<lol_challenges_v1::ApexPlayerInfo>>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/challenges/v1/challenges/{}/leaderboards/by-level/{}", challenge_id, level));
let request = if let Some(limit) = limit { request.query(&[ ("limit", limit) ]) } else { request };
let future = self.base.execute_opt::<Vec<lol_challenges_v1::ApexPlayerInfo>>("lol-challenges-v1.getChallengeLeaderboards", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lol-challenges-v1.getChallengeLeaderboards"));
future
}
pub fn get_challenge_percentiles(&self, route: PlatformRoute, challenge_id: i64)
-> impl Future<Output = Result<Option<std::collections::HashMap<crate::consts::Tier, f64>>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/challenges/v1/challenges/{}/percentiles", challenge_id));
let future = self.base.execute_opt::<std::collections::HashMap<crate::consts::Tier, f64>>("lol-challenges-v1.getChallengePercentiles", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lol-challenges-v1.getChallengePercentiles"));
future
}
pub fn get_player_data(&self, route: PlatformRoute, puuid: &str)
-> impl Future<Output = Result<lol_challenges_v1::PlayerInfo>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/challenges/v1/player-data/{}", puuid));
let future = self.base.execute_val::<lol_challenges_v1::PlayerInfo>("lol-challenges-v1.getPlayerData", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lol-challenges-v1.getPlayerData"));
future
}
}
#[repr(transparent)]
pub struct LolStatusV3<'a> {
base: &'a RiotApi,
}
impl<'a> LolStatusV3<'a> {
pub fn get_shard_data(&self, route: PlatformRoute)
-> impl Future<Output = Result<lol_status_v3::ShardStatus>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/lol/status/v3/shard-data");
let future = self.base.execute_val::<lol_status_v3::ShardStatus>("lol-status-v3.getShardData", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lol-status-v3.getShardData"));
future
}
}
#[repr(transparent)]
pub struct LolStatusV4<'a> {
base: &'a RiotApi,
}
impl<'a> LolStatusV4<'a> {
pub fn get_platform_data(&self, route: PlatformRoute)
-> impl Future<Output = Result<lol_status_v4::PlatformData>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/lol/status/v4/platform-data");
let future = self.base.execute_val::<lol_status_v4::PlatformData>("lol-status-v4.getPlatformData", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lol-status-v4.getPlatformData"));
future
}
}
#[repr(transparent)]
pub struct LorDeckV1<'a> {
base: &'a RiotApi,
}
impl<'a> LorDeckV1<'a> {
pub fn get_decks(&self, route: RegionalRoute, authorization: &str)
-> impl Future<Output = Result<Vec<lor_deck_v1::Deck>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/lor/deck/v1/decks/me");
let request = request.header("Authorization", authorization);
let future = self.base.execute_val::<Vec<lor_deck_v1::Deck>>("lor-deck-v1.getDecks", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lor-deck-v1.getDecks"));
future
}
pub fn create_deck(&self, route: RegionalRoute, body: &lor_deck_v1::NewDeck, authorization: &str)
-> impl Future<Output = Result<String>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::POST, route_str, "/lor/deck/v1/decks/me");
let request = request.header("Authorization", authorization);
let request = request.body(serde_json::ser::to_vec(body).unwrap());
let future = self.base.execute_val::<String>("lor-deck-v1.createDeck", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lor-deck-v1.createDeck"));
future
}
}
#[repr(transparent)]
pub struct LorInventoryV1<'a> {
base: &'a RiotApi,
}
impl<'a> LorInventoryV1<'a> {
pub fn get_cards(&self, route: RegionalRoute, authorization: &str)
-> impl Future<Output = Result<Vec<lor_inventory_v1::Card>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/lor/inventory/v1/cards/me");
let request = request.header("Authorization", authorization);
let future = self.base.execute_val::<Vec<lor_inventory_v1::Card>>("lor-inventory-v1.getCards", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lor-inventory-v1.getCards"));
future
}
}
#[repr(transparent)]
pub struct LorMatchV1<'a> {
base: &'a RiotApi,
}
impl<'a> LorMatchV1<'a> {
pub fn get_match_ids_by_puuid(&self, route: RegionalRoute, puuid: &str)
-> impl Future<Output = Result<Vec<String>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lor/match/v1/matches/by-puuid/{}/ids", puuid));
let future = self.base.execute_val::<Vec<String>>("lor-match-v1.getMatchIdsByPUUID", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lor-match-v1.getMatchIdsByPUUID"));
future
}
pub fn get_match(&self, route: RegionalRoute, match_id: &str)
-> impl Future<Output = Result<lor_match_v1::Match>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lor/match/v1/matches/{}", match_id));
let future = self.base.execute_val::<lor_match_v1::Match>("lor-match-v1.getMatch", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lor-match-v1.getMatch"));
future
}
}
#[repr(transparent)]
pub struct LorRankedV1<'a> {
base: &'a RiotApi,
}
impl<'a> LorRankedV1<'a> {
pub fn get_leaderboards(&self, route: RegionalRoute)
-> impl Future<Output = Result<lor_ranked_v1::Leaderboard>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/lor/ranked/v1/leaderboards");
let future = self.base.execute_val::<lor_ranked_v1::Leaderboard>("lor-ranked-v1.getLeaderboards", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lor-ranked-v1.getLeaderboards"));
future
}
}
#[repr(transparent)]
pub struct LorStatusV1<'a> {
base: &'a RiotApi,
}
impl<'a> LorStatusV1<'a> {
pub fn get_platform_data(&self, route: RegionalRoute)
-> impl Future<Output = Result<lor_status_v1::PlatformData>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/lor/status/v1/platform-data");
let future = self.base.execute_val::<lor_status_v1::PlatformData>("lor-status-v1.getPlatformData", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("lor-status-v1.getPlatformData"));
future
}
}
#[repr(transparent)]
pub struct MatchV5<'a> {
base: &'a RiotApi,
}
impl<'a> MatchV5<'a> {
pub fn get_match_ids_by_puuid(&self, route: RegionalRoute, puuid: &str, count: Option<i32>, end_time: Option<i64>, queue: Option<crate::consts::Queue>, start_time: Option<i64>, start: Option<i32>, r#type: Option<&str>)
-> impl Future<Output = Result<Vec<String>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/match/v5/matches/by-puuid/{}/ids", puuid));
let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
let request = if let Some(end_time) = end_time { request.query(&[ ("endTime", end_time) ]) } else { request };
let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
let request = if let Some(start_time) = start_time { request.query(&[ ("startTime", start_time) ]) } else { request };
let request = if let Some(start) = start { request.query(&[ ("start", start) ]) } else { request };
let request = if let Some(r#type) = r#type { request.query(&[ ("type", r#type) ]) } else { request };
let future = self.base.execute_val::<Vec<String>>("match-v5.getMatchIdsByPUUID", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("match-v5.getMatchIdsByPUUID"));
future
}
pub fn get_match(&self, route: RegionalRoute, match_id: &str)
-> impl Future<Output = Result<Option<match_v5::Match>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/match/v5/matches/{}", match_id));
let future = self.base.execute_opt::<match_v5::Match>("match-v5.getMatch", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("match-v5.getMatch"));
future
}
pub fn get_timeline(&self, route: RegionalRoute, match_id: &str)
-> impl Future<Output = Result<Option<match_v5::MatchTimeline>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/match/v5/matches/{}/timeline", match_id));
let future = self.base.execute_opt::<match_v5::MatchTimeline>("match-v5.getTimeline", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("match-v5.getTimeline"));
future
}
}
#[repr(transparent)]
pub struct SpectatorTftV5<'a> {
base: &'a RiotApi,
}
impl<'a> SpectatorTftV5<'a> {
pub fn get_current_game_info_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str)
-> impl Future<Output = Result<Option<spectator_tft_v5::CurrentGameInfo>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/spectator/tft/v5/active-games/by-puuid/{}", encrypted_puuid));
let future = self.base.execute_opt::<spectator_tft_v5::CurrentGameInfo>("spectator-tft-v5.getCurrentGameInfoByPuuid", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("spectator-tft-v5.getCurrentGameInfoByPuuid"));
future
}
pub fn get_featured_games(&self, route: PlatformRoute)
-> impl Future<Output = Result<spectator_tft_v5::FeaturedGames>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/lol/spectator/tft/v5/featured-games");
let future = self.base.execute_val::<spectator_tft_v5::FeaturedGames>("spectator-tft-v5.getFeaturedGames", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("spectator-tft-v5.getFeaturedGames"));
future
}
}
#[repr(transparent)]
pub struct SpectatorV4<'a> {
base: &'a RiotApi,
}
impl<'a> SpectatorV4<'a> {
pub fn get_current_game_info_by_summoner(&self, route: PlatformRoute, encrypted_summoner_id: &str)
-> impl Future<Output = Result<Option<spectator_v4::CurrentGameInfo>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/spectator/v4/active-games/by-summoner/{}", encrypted_summoner_id));
let future = self.base.execute_opt::<spectator_v4::CurrentGameInfo>("spectator-v4.getCurrentGameInfoBySummoner", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("spectator-v4.getCurrentGameInfoBySummoner"));
future
}
pub fn get_featured_games(&self, route: PlatformRoute)
-> impl Future<Output = Result<spectator_v4::FeaturedGames>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/lol/spectator/v4/featured-games");
let future = self.base.execute_val::<spectator_v4::FeaturedGames>("spectator-v4.getFeaturedGames", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("spectator-v4.getFeaturedGames"));
future
}
}
#[repr(transparent)]
pub struct SpectatorV5<'a> {
base: &'a RiotApi,
}
impl<'a> SpectatorV5<'a> {
pub fn get_current_game_info_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str)
-> impl Future<Output = Result<Option<spectator_v5::CurrentGameInfo>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/spectator/v5/active-games/by-summoner/{}", encrypted_puuid));
let future = self.base.execute_opt::<spectator_v5::CurrentGameInfo>("spectator-v5.getCurrentGameInfoByPuuid", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("spectator-v5.getCurrentGameInfoByPuuid"));
future
}
pub fn get_featured_games(&self, route: PlatformRoute)
-> impl Future<Output = Result<spectator_v5::FeaturedGames>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/lol/spectator/v5/featured-games");
let future = self.base.execute_val::<spectator_v5::FeaturedGames>("spectator-v5.getFeaturedGames", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("spectator-v5.getFeaturedGames"));
future
}
}
#[repr(transparent)]
pub struct SummonerV4<'a> {
base: &'a RiotApi,
}
impl<'a> SummonerV4<'a> {
pub fn get_by_rsopuuid(&self, route: PlatformRoute, rso_puuid: &str)
-> impl Future<Output = Result<summoner_v4::Summoner>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/fulfillment/v1/summoners/by-puuid/{}", rso_puuid));
let future = self.base.execute_val::<summoner_v4::Summoner>("summoner-v4.getByRSOPUUID", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("summoner-v4.getByRSOPUUID"));
future
}
pub fn get_by_account_id(&self, route: PlatformRoute, encrypted_account_id: &str)
-> impl Future<Output = Result<summoner_v4::Summoner>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/summoner/v4/summoners/by-account/{}", encrypted_account_id));
let future = self.base.execute_val::<summoner_v4::Summoner>("summoner-v4.getByAccountId", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("summoner-v4.getByAccountId"));
future
}
pub fn get_by_summoner_name(&self, route: PlatformRoute, summoner_name: &str)
-> impl Future<Output = Result<Option<summoner_v4::Summoner>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/summoner/v4/summoners/by-name/{}", summoner_name));
let future = self.base.execute_opt::<summoner_v4::Summoner>("summoner-v4.getBySummonerName", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("summoner-v4.getBySummonerName"));
future
}
pub fn get_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str)
-> impl Future<Output = Result<summoner_v4::Summoner>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/summoner/v4/summoners/by-puuid/{}", encrypted_puuid));
let future = self.base.execute_val::<summoner_v4::Summoner>("summoner-v4.getByPUUID", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("summoner-v4.getByPUUID"));
future
}
pub fn get_by_access_token(&self, route: PlatformRoute, authorization: Option<&str>)
-> impl Future<Output = Result<summoner_v4::Summoner>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/lol/summoner/v4/summoners/me");
let mut request = request; if let Some(authorization) = authorization { request = request.header("Authorization", authorization); }
let future = self.base.execute_val::<summoner_v4::Summoner>("summoner-v4.getByAccessToken", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("summoner-v4.getByAccessToken"));
future
}
pub fn get_by_summoner_id(&self, route: PlatformRoute, encrypted_summoner_id: &str)
-> impl Future<Output = Result<summoner_v4::Summoner>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/summoner/v4/summoners/{}", encrypted_summoner_id));
let future = self.base.execute_val::<summoner_v4::Summoner>("summoner-v4.getBySummonerId", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("summoner-v4.getBySummonerId"));
future
}
}
#[repr(transparent)]
pub struct TftLeagueV1<'a> {
base: &'a RiotApi,
}
impl<'a> TftLeagueV1<'a> {
pub fn get_challenger_league(&self, route: PlatformRoute, queue: Option<&str>)
-> impl Future<Output = Result<tft_league_v1::LeagueList>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/tft/league/v1/challenger");
let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
let future = self.base.execute_val::<tft_league_v1::LeagueList>("tft-league-v1.getChallengerLeague", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-league-v1.getChallengerLeague"));
future
}
pub fn get_league_entries_for_summoner(&self, route: PlatformRoute, summoner_id: &str)
-> impl Future<Output = Result<Vec<tft_league_v1::LeagueEntry>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/tft/league/v1/entries/by-summoner/{}", summoner_id));
let future = self.base.execute_val::<Vec<tft_league_v1::LeagueEntry>>("tft-league-v1.getLeagueEntriesForSummoner", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-league-v1.getLeagueEntriesForSummoner"));
future
}
pub fn get_league_entries(&self, route: PlatformRoute, tier: crate::consts::Tier, division: &str, page: Option<i32>, queue: Option<&str>)
-> impl Future<Output = Result<Vec<tft_league_v1::LeagueEntry>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/tft/league/v1/entries/{}/{}", tier, division));
let request = if let Some(page) = page { request.query(&[ ("page", page) ]) } else { request };
let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
let future = self.base.execute_val::<Vec<tft_league_v1::LeagueEntry>>("tft-league-v1.getLeagueEntries", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-league-v1.getLeagueEntries"));
future
}
pub fn get_grandmaster_league(&self, route: PlatformRoute, queue: Option<&str>)
-> impl Future<Output = Result<tft_league_v1::LeagueList>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/tft/league/v1/grandmaster");
let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
let future = self.base.execute_val::<tft_league_v1::LeagueList>("tft-league-v1.getGrandmasterLeague", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-league-v1.getGrandmasterLeague"));
future
}
pub fn get_league_by_id(&self, route: PlatformRoute, league_id: &str)
-> impl Future<Output = Result<Option<tft_league_v1::LeagueList>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/tft/league/v1/leagues/{}", league_id));
let future = self.base.execute_opt::<tft_league_v1::LeagueList>("tft-league-v1.getLeagueById", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-league-v1.getLeagueById"));
future
}
pub fn get_master_league(&self, route: PlatformRoute, queue: Option<&str>)
-> impl Future<Output = Result<tft_league_v1::LeagueList>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/tft/league/v1/master");
let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
let future = self.base.execute_val::<tft_league_v1::LeagueList>("tft-league-v1.getMasterLeague", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-league-v1.getMasterLeague"));
future
}
pub fn get_top_rated_ladder(&self, route: PlatformRoute, queue: crate::consts::QueueType)
-> impl Future<Output = Result<Vec<tft_league_v1::TopRatedLadderEntry>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/tft/league/v1/rated-ladders/{}/top", queue));
let future = self.base.execute_val::<Vec<tft_league_v1::TopRatedLadderEntry>>("tft-league-v1.getTopRatedLadder", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-league-v1.getTopRatedLadder"));
future
}
}
#[repr(transparent)]
pub struct TftMatchV1<'a> {
base: &'a RiotApi,
}
impl<'a> TftMatchV1<'a> {
pub fn get_match_ids_by_puuid(&self, route: RegionalRoute, puuid: &str, count: Option<i32>, end_time: Option<i64>, start: Option<i32>, start_time: Option<i64>)
-> impl Future<Output = Result<Vec<String>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/tft/match/v1/matches/by-puuid/{}/ids", puuid));
let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
let request = if let Some(end_time) = end_time { request.query(&[ ("endTime", end_time) ]) } else { request };
let request = if let Some(start) = start { request.query(&[ ("start", start) ]) } else { request };
let request = if let Some(start_time) = start_time { request.query(&[ ("startTime", start_time) ]) } else { request };
let future = self.base.execute_val::<Vec<String>>("tft-match-v1.getMatchIdsByPUUID", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-match-v1.getMatchIdsByPUUID"));
future
}
pub fn get_match(&self, route: RegionalRoute, match_id: &str)
-> impl Future<Output = Result<Option<tft_match_v1::Match>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/tft/match/v1/matches/{}", match_id));
let future = self.base.execute_opt::<tft_match_v1::Match>("tft-match-v1.getMatch", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-match-v1.getMatch"));
future
}
}
#[repr(transparent)]
pub struct TftStatusV1<'a> {
base: &'a RiotApi,
}
impl<'a> TftStatusV1<'a> {
pub fn get_platform_data(&self, route: PlatformRoute)
-> impl Future<Output = Result<tft_status_v1::PlatformData>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/tft/status/v1/platform-data");
let future = self.base.execute_val::<tft_status_v1::PlatformData>("tft-status-v1.getPlatformData", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-status-v1.getPlatformData"));
future
}
}
#[repr(transparent)]
pub struct TftSummonerV1<'a> {
base: &'a RiotApi,
}
impl<'a> TftSummonerV1<'a> {
pub fn get_by_account_id(&self, route: PlatformRoute, encrypted_account_id: &str)
-> impl Future<Output = Result<tft_summoner_v1::Summoner>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/tft/summoner/v1/summoners/by-account/{}", encrypted_account_id));
let future = self.base.execute_val::<tft_summoner_v1::Summoner>("tft-summoner-v1.getByAccountId", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-summoner-v1.getByAccountId"));
future
}
pub fn get_by_summoner_name(&self, route: PlatformRoute, summoner_name: &str)
-> impl Future<Output = Result<Option<tft_summoner_v1::Summoner>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/tft/summoner/v1/summoners/by-name/{}", summoner_name));
let future = self.base.execute_opt::<tft_summoner_v1::Summoner>("tft-summoner-v1.getBySummonerName", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-summoner-v1.getBySummonerName"));
future
}
pub fn get_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str)
-> impl Future<Output = Result<tft_summoner_v1::Summoner>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/tft/summoner/v1/summoners/by-puuid/{}", encrypted_puuid));
let future = self.base.execute_val::<tft_summoner_v1::Summoner>("tft-summoner-v1.getByPUUID", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-summoner-v1.getByPUUID"));
future
}
pub fn get_by_access_token(&self, route: PlatformRoute, authorization: Option<&str>)
-> impl Future<Output = Result<tft_summoner_v1::Summoner>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/tft/summoner/v1/summoners/me");
let mut request = request; if let Some(authorization) = authorization { request = request.header("Authorization", authorization); }
let future = self.base.execute_val::<tft_summoner_v1::Summoner>("tft-summoner-v1.getByAccessToken", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-summoner-v1.getByAccessToken"));
future
}
pub fn get_by_summoner_id(&self, route: PlatformRoute, encrypted_summoner_id: &str)
-> impl Future<Output = Result<tft_summoner_v1::Summoner>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/tft/summoner/v1/summoners/{}", encrypted_summoner_id));
let future = self.base.execute_val::<tft_summoner_v1::Summoner>("tft-summoner-v1.getBySummonerId", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tft-summoner-v1.getBySummonerId"));
future
}
}
#[repr(transparent)]
pub struct TournamentStubV5<'a> {
base: &'a RiotApi,
}
impl<'a> TournamentStubV5<'a> {
pub fn create_tournament_code(&self, route: RegionalRoute, body: &tournament_stub_v5::TournamentCodeParametersV5, tournament_id: i64, count: Option<i32>)
-> impl Future<Output = Result<Vec<String>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::POST, route_str, "/lol/tournament-stub/v5/codes");
let request = request.query(&[ ("tournamentId", tournament_id) ]);
let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
let request = request.body(serde_json::ser::to_vec(body).unwrap());
let future = self.base.execute_val::<Vec<String>>("tournament-stub-v5.createTournamentCode", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tournament-stub-v5.createTournamentCode"));
future
}
pub fn get_tournament_code(&self, route: RegionalRoute, tournament_code: &str)
-> impl Future<Output = Result<tournament_stub_v5::TournamentCodeV5>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament-stub/v5/codes/{}", tournament_code));
let future = self.base.execute_val::<tournament_stub_v5::TournamentCodeV5>("tournament-stub-v5.getTournamentCode", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tournament-stub-v5.getTournamentCode"));
future
}
pub fn get_lobby_events_by_code(&self, route: RegionalRoute, tournament_code: &str)
-> impl Future<Output = Result<tournament_stub_v5::LobbyEventV5Wrapper>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament-stub/v5/lobby-events/by-code/{}", tournament_code));
let future = self.base.execute_val::<tournament_stub_v5::LobbyEventV5Wrapper>("tournament-stub-v5.getLobbyEventsByCode", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tournament-stub-v5.getLobbyEventsByCode"));
future
}
pub fn register_provider_data(&self, route: RegionalRoute, body: &tournament_stub_v5::ProviderRegistrationParametersV5)
-> impl Future<Output = Result<i32>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::POST, route_str, "/lol/tournament-stub/v5/providers");
let request = request.body(serde_json::ser::to_vec(body).unwrap());
let future = self.base.execute_val::<i32>("tournament-stub-v5.registerProviderData", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tournament-stub-v5.registerProviderData"));
future
}
pub fn register_tournament(&self, route: RegionalRoute, body: &tournament_stub_v5::TournamentRegistrationParametersV5)
-> impl Future<Output = Result<i32>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::POST, route_str, "/lol/tournament-stub/v5/tournaments");
let request = request.body(serde_json::ser::to_vec(body).unwrap());
let future = self.base.execute_val::<i32>("tournament-stub-v5.registerTournament", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tournament-stub-v5.registerTournament"));
future
}
}
#[repr(transparent)]
pub struct TournamentV5<'a> {
base: &'a RiotApi,
}
impl<'a> TournamentV5<'a> {
pub fn create_tournament_code(&self, route: RegionalRoute, body: &tournament_v5::TournamentCodeParametersV5, tournament_id: i64, count: Option<i32>)
-> impl Future<Output = Result<Vec<String>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::POST, route_str, "/lol/tournament/v5/codes");
let request = request.query(&[ ("tournamentId", tournament_id) ]);
let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
let request = request.body(serde_json::ser::to_vec(body).unwrap());
let future = self.base.execute_val::<Vec<String>>("tournament-v5.createTournamentCode", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tournament-v5.createTournamentCode"));
future
}
pub fn get_tournament_code(&self, route: RegionalRoute, tournament_code: &str)
-> impl Future<Output = Result<tournament_v5::TournamentCodeV5>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament/v5/codes/{}", tournament_code));
let future = self.base.execute_val::<tournament_v5::TournamentCodeV5>("tournament-v5.getTournamentCode", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tournament-v5.getTournamentCode"));
future
}
pub fn update_code(&self, route: RegionalRoute, body: &tournament_v5::TournamentCodeUpdateParametersV5, tournament_code: &str)
-> impl Future<Output = Result<()>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::PUT, route_str, &format!("/lol/tournament/v5/codes/{}", tournament_code));
let request = request.body(serde_json::ser::to_vec(body).unwrap());
let future = self.base.execute("tournament-v5.updateCode", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tournament-v5.updateCode"));
future
}
pub fn get_games(&self, route: RegionalRoute, tournament_code: &str)
-> impl Future<Output = Result<Vec<tournament_v5::TournamentGamesV5>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament/v5/games/by-code/{}", tournament_code));
let future = self.base.execute_val::<Vec<tournament_v5::TournamentGamesV5>>("tournament-v5.getGames", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tournament-v5.getGames"));
future
}
pub fn get_lobby_events_by_code(&self, route: RegionalRoute, tournament_code: &str)
-> impl Future<Output = Result<tournament_v5::LobbyEventV5Wrapper>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament/v5/lobby-events/by-code/{}", tournament_code));
let future = self.base.execute_val::<tournament_v5::LobbyEventV5Wrapper>("tournament-v5.getLobbyEventsByCode", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tournament-v5.getLobbyEventsByCode"));
future
}
pub fn register_provider_data(&self, route: RegionalRoute, body: &tournament_v5::ProviderRegistrationParametersV5)
-> impl Future<Output = Result<i32>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::POST, route_str, "/lol/tournament/v5/providers");
let request = request.body(serde_json::ser::to_vec(body).unwrap());
let future = self.base.execute_val::<i32>("tournament-v5.registerProviderData", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tournament-v5.registerProviderData"));
future
}
pub fn register_tournament(&self, route: RegionalRoute, body: &tournament_v5::TournamentRegistrationParametersV5)
-> impl Future<Output = Result<i32>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::POST, route_str, "/lol/tournament/v5/tournaments");
let request = request.body(serde_json::ser::to_vec(body).unwrap());
let future = self.base.execute_val::<i32>("tournament-v5.registerTournament", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("tournament-v5.registerTournament"));
future
}
}
#[repr(transparent)]
pub struct ValContentV1<'a> {
base: &'a RiotApi,
}
impl<'a> ValContentV1<'a> {
pub fn get_content(&self, route: ValPlatformRoute, locale: Option<&str>)
-> impl Future<Output = Result<val_content_v1::Content>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/val/content/v1/contents");
let request = if let Some(locale) = locale { request.query(&[ ("locale", locale) ]) } else { request };
let future = self.base.execute_val::<val_content_v1::Content>("val-content-v1.getContent", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("val-content-v1.getContent"));
future
}
}
#[repr(transparent)]
pub struct ValMatchV1<'a> {
base: &'a RiotApi,
}
impl<'a> ValMatchV1<'a> {
pub fn get_match(&self, route: ValPlatformRoute, match_id: &str)
-> impl Future<Output = Result<Option<val_match_v1::Match>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/val/match/v1/matches/{}", match_id));
let future = self.base.execute_opt::<val_match_v1::Match>("val-match-v1.getMatch", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("val-match-v1.getMatch"));
future
}
pub fn get_matchlist(&self, route: ValPlatformRoute, puuid: &str)
-> impl Future<Output = Result<val_match_v1::Matchlist>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/val/match/v1/matchlists/by-puuid/{}", puuid));
let future = self.base.execute_val::<val_match_v1::Matchlist>("val-match-v1.getMatchlist", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("val-match-v1.getMatchlist"));
future
}
pub fn get_recent(&self, route: ValPlatformRoute, queue: &str)
-> impl Future<Output = Result<val_match_v1::RecentMatches>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/val/match/v1/recent-matches/by-queue/{}", queue));
let future = self.base.execute_val::<val_match_v1::RecentMatches>("val-match-v1.getRecent", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("val-match-v1.getRecent"));
future
}
}
#[repr(transparent)]
pub struct ValRankedV1<'a> {
base: &'a RiotApi,
}
impl<'a> ValRankedV1<'a> {
pub fn get_leaderboard(&self, route: ValPlatformRoute, act_id: &str, size: Option<i32>, start_index: Option<i32>)
-> impl Future<Output = Result<Option<val_ranked_v1::Leaderboard>>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, &format!("/val/ranked/v1/leaderboards/by-act/{}", act_id));
let request = if let Some(size) = size { request.query(&[ ("size", size) ]) } else { request };
let request = if let Some(start_index) = start_index { request.query(&[ ("startIndex", start_index) ]) } else { request };
let future = self.base.execute_opt::<val_ranked_v1::Leaderboard>("val-ranked-v1.getLeaderboard", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("val-ranked-v1.getLeaderboard"));
future
}
}
#[repr(transparent)]
pub struct ValStatusV1<'a> {
base: &'a RiotApi,
}
impl<'a> ValStatusV1<'a> {
pub fn get_platform_data(&self, route: ValPlatformRoute)
-> impl Future<Output = Result<val_status_v1::PlatformData>> + 'a
{
let route_str = route.into();
let request = self.base.request(Method::GET, route_str, "/val/status/v1/platform-data");
let future = self.base.execute_val::<val_status_v1::PlatformData>("val-status-v1.getPlatformData", route_str, request);
#[cfg(feature = "tracing")]
let future = future.instrument(tracing::info_span!("val-status-v1.getPlatformData"));
future
}
}