1#![cfg_attr(any(), rustfmt::skip)]
2#![allow(clippy::let_and_return, clippy::too_many_arguments)]
15
16use std::future::Future;
17use std::vec::Vec;
18
19#[cfg(feature="metrics")]
20use crate::metrics;
21
22#[cfg(feature="tracing")]
23use tracing::Instrument;
24use reqwest::Method;
25
26use crate::{Result, TryRequestResult};
27use crate::consts::{ RegionalRoute, PlatformRoute, ValPlatformRoute };
28use crate::riot_api::RiotApi;
29
30impl RiotApi {
31 #[inline]
37 pub fn account_v1(&self) -> AccountV1<'_> {
38 AccountV1 { base: self }
39 }
40 #[inline]
46 pub fn champion_mastery_v4(&self) -> ChampionMasteryV4<'_> {
47 ChampionMasteryV4 { base: self }
48 }
49 #[inline]
55 pub fn champion_v3(&self) -> ChampionV3<'_> {
56 ChampionV3 { base: self }
57 }
58 #[inline]
64 pub fn clash_v1(&self) -> ClashV1<'_> {
65 ClashV1 { base: self }
66 }
67 #[inline]
73 pub fn league_exp_v4(&self) -> LeagueExpV4<'_> {
74 LeagueExpV4 { base: self }
75 }
76 #[inline]
82 pub fn league_v4(&self) -> LeagueV4<'_> {
83 LeagueV4 { base: self }
84 }
85 #[inline]
91 pub fn lol_challenges_v1(&self) -> LolChallengesV1<'_> {
92 LolChallengesV1 { base: self }
93 }
94 #[inline]
100 pub fn lol_rso_match_v1(&self) -> LolRsoMatchV1<'_> {
101 LolRsoMatchV1 { base: self }
102 }
103 #[inline]
109 pub fn lol_status_v4(&self) -> LolStatusV4<'_> {
110 LolStatusV4 { base: self }
111 }
112 #[inline]
118 pub fn lor_deck_v1(&self) -> LorDeckV1<'_> {
119 LorDeckV1 { base: self }
120 }
121 #[inline]
127 pub fn lor_inventory_v1(&self) -> LorInventoryV1<'_> {
128 LorInventoryV1 { base: self }
129 }
130 #[inline]
136 pub fn lor_match_v1(&self) -> LorMatchV1<'_> {
137 LorMatchV1 { base: self }
138 }
139 #[inline]
145 pub fn lor_ranked_v1(&self) -> LorRankedV1<'_> {
146 LorRankedV1 { base: self }
147 }
148 #[inline]
154 pub fn lor_status_v1(&self) -> LorStatusV1<'_> {
155 LorStatusV1 { base: self }
156 }
157 #[inline]
163 pub fn match_v5(&self) -> MatchV5<'_> {
164 MatchV5 { base: self }
165 }
166 #[inline]
172 pub fn riftbound_content_v1(&self) -> RiftboundContentV1<'_> {
173 RiftboundContentV1 { base: self }
174 }
175 #[inline]
181 pub fn spectator_tft_v5(&self) -> SpectatorTftV5<'_> {
182 SpectatorTftV5 { base: self }
183 }
184 #[inline]
190 pub fn spectator_v5(&self) -> SpectatorV5<'_> {
191 SpectatorV5 { base: self }
192 }
193 #[inline]
199 pub fn summoner_v4(&self) -> SummonerV4<'_> {
200 SummonerV4 { base: self }
201 }
202 #[inline]
208 pub fn tft_league_v1(&self) -> TftLeagueV1<'_> {
209 TftLeagueV1 { base: self }
210 }
211 #[inline]
217 pub fn tft_match_v1(&self) -> TftMatchV1<'_> {
218 TftMatchV1 { base: self }
219 }
220 #[inline]
226 pub fn tft_status_v1(&self) -> TftStatusV1<'_> {
227 TftStatusV1 { base: self }
228 }
229 #[inline]
235 pub fn tft_summoner_v1(&self) -> TftSummonerV1<'_> {
236 TftSummonerV1 { base: self }
237 }
238 #[inline]
244 pub fn tournament_stub_v5(&self) -> TournamentStubV5<'_> {
245 TournamentStubV5 { base: self }
246 }
247 #[inline]
253 pub fn tournament_v5(&self) -> TournamentV5<'_> {
254 TournamentV5 { base: self }
255 }
256 #[inline]
262 pub fn val_console_match_v1(&self) -> ValConsoleMatchV1<'_> {
263 ValConsoleMatchV1 { base: self }
264 }
265 #[inline]
271 pub fn val_console_ranked_v1(&self) -> ValConsoleRankedV1<'_> {
272 ValConsoleRankedV1 { base: self }
273 }
274 #[inline]
280 pub fn val_content_v1(&self) -> ValContentV1<'_> {
281 ValContentV1 { base: self }
282 }
283 #[inline]
289 pub fn val_match_v1(&self) -> ValMatchV1<'_> {
290 ValMatchV1 { base: self }
291 }
292 #[inline]
298 pub fn val_ranked_v1(&self) -> ValRankedV1<'_> {
299 ValRankedV1 { base: self }
300 }
301 #[inline]
307 pub fn val_status_v1(&self) -> ValStatusV1<'_> {
308 ValStatusV1 { base: self }
309 }
310}
311
312#[repr(transparent)]
318pub struct AccountV1<'a> {
319 base: &'a RiotApi,
320}
321impl<'a> AccountV1<'a> {
322 pub fn get_by_puuid(&self, route: RegionalRoute, puuid: &str)
331 -> impl Future<Output = Result<crate::models::account_v1::Account>> + 'a
332 {
333 let route_str = route.into();
334 let request = self.base.request(Method::GET, route_str, &format!("/riot/account/v1/accounts/by-puuid/{}", puuid));
335 let future = self.base.execute_val::<crate::models::account_v1::Account>("account-v1.getByPuuid", route_str, request);
336 #[cfg(feature = "tracing")]
337 let future = future.instrument(tracing::info_span!("account-v1.getByPuuid", route = route_str));
338 #[cfg(feature = "metrics")]
339 let future = metrics::timed(future, "account-v1.getByPuuid", route_str);
340 future
341 }
342
343 pub fn try_get_by_puuid(&self, min_capacity: f32, route: RegionalRoute, puuid: &str)
354 -> impl Future<Output = TryRequestResult<crate::models::account_v1::Account>> + 'a
355 {
356 let route_str = route.into();
357 let request = self.base.request(Method::GET, route_str, &format!("/riot/account/v1/accounts/by-puuid/{}", puuid));
358 let future = self.base.try_execute_val::<crate::models::account_v1::Account>("account-v1.getByPuuid", route_str, request, min_capacity);
359 #[cfg(feature = "tracing")]
360 let future = future.instrument(tracing::info_span!("account-v1.getByPuuid", route = route_str));
361 #[cfg(feature = "metrics")]
362 let future = metrics::try_timed(future, "account-v1.getByPuuid", route_str);
363 future
364 }
365
366 pub fn get_by_riot_id(&self, route: RegionalRoute, game_name: &str, tag_line: &str)
376 -> impl Future<Output = Result<Option<crate::models::account_v1::Account>>> + 'a
377 {
378 let route_str = route.into();
379 let request = self.base.request(Method::GET, route_str, &format!("/riot/account/v1/accounts/by-riot-id/{}/{}", game_name, tag_line));
380 let future = self.base.execute_opt::<crate::models::account_v1::Account>("account-v1.getByRiotId", route_str, request);
381 #[cfg(feature = "tracing")]
382 let future = future.instrument(tracing::info_span!("account-v1.getByRiotId", route = route_str));
383 #[cfg(feature = "metrics")]
384 let future = metrics::timed(future, "account-v1.getByRiotId", route_str);
385 future
386 }
387
388 pub fn try_get_by_riot_id(&self, min_capacity: f32, route: RegionalRoute, game_name: &str, tag_line: &str)
400 -> impl Future<Output = TryRequestResult<Option<crate::models::account_v1::Account>>> + 'a
401 {
402 let route_str = route.into();
403 let request = self.base.request(Method::GET, route_str, &format!("/riot/account/v1/accounts/by-riot-id/{}/{}", game_name, tag_line));
404 let future = self.base.try_execute_opt::<crate::models::account_v1::Account>("account-v1.getByRiotId", route_str, request, min_capacity);
405 #[cfg(feature = "tracing")]
406 let future = future.instrument(tracing::info_span!("account-v1.getByRiotId", route = route_str));
407 #[cfg(feature = "metrics")]
408 let future = metrics::try_timed(future, "account-v1.getByRiotId", route_str);
409 future
410 }
411
412 pub fn get_by_access_token(&self, route: RegionalRoute, access_token: impl std::fmt::Display)
424 -> impl Future<Output = Result<crate::models::account_v1::Account>> + 'a
425 {
426 let route_str = route.into();
427 let request = self.base.request(Method::GET, route_str, "/riot/account/v1/accounts/me");
428 let mut request = request.bearer_auth(access_token);
429 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
430 let future = self.base.execute_val::<crate::models::account_v1::Account>("account-v1.getByAccessToken", route_str, request);
431 #[cfg(feature = "tracing")]
432 let future = future.instrument(tracing::info_span!("account-v1.getByAccessToken", route = route_str));
433 #[cfg(feature = "metrics")]
434 let future = metrics::timed(future, "account-v1.getByAccessToken", route_str);
435 future
436 }
437
438 pub fn try_get_by_access_token(&self, min_capacity: f32, route: RegionalRoute, access_token: impl std::fmt::Display)
452 -> impl Future<Output = TryRequestResult<crate::models::account_v1::Account>> + 'a
453 {
454 let route_str = route.into();
455 let request = self.base.request(Method::GET, route_str, "/riot/account/v1/accounts/me");
456 let mut request = request.bearer_auth(access_token);
457 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
458 let future = self.base.try_execute_val::<crate::models::account_v1::Account>("account-v1.getByAccessToken", route_str, request, min_capacity);
459 #[cfg(feature = "tracing")]
460 let future = future.instrument(tracing::info_span!("account-v1.getByAccessToken", route = route_str));
461 #[cfg(feature = "metrics")]
462 let future = metrics::try_timed(future, "account-v1.getByAccessToken", route_str);
463 future
464 }
465
466 pub fn get_active_shard(&self, route: RegionalRoute, game: &str, puuid: &str)
476 -> impl Future<Output = Result<Option<crate::models::account_v1::ActiveShard>>> + 'a
477 {
478 let route_str = route.into();
479 let request = self.base.request(Method::GET, route_str, &format!("/riot/account/v1/active-shards/by-game/{}/by-puuid/{}", game, puuid));
480 let future = self.base.execute_opt::<crate::models::account_v1::ActiveShard>("account-v1.getActiveShard", route_str, request);
481 #[cfg(feature = "tracing")]
482 let future = future.instrument(tracing::info_span!("account-v1.getActiveShard", route = route_str));
483 #[cfg(feature = "metrics")]
484 let future = metrics::timed(future, "account-v1.getActiveShard", route_str);
485 future
486 }
487
488 pub fn try_get_active_shard(&self, min_capacity: f32, route: RegionalRoute, game: &str, puuid: &str)
500 -> impl Future<Output = TryRequestResult<Option<crate::models::account_v1::ActiveShard>>> + 'a
501 {
502 let route_str = route.into();
503 let request = self.base.request(Method::GET, route_str, &format!("/riot/account/v1/active-shards/by-game/{}/by-puuid/{}", game, puuid));
504 let future = self.base.try_execute_opt::<crate::models::account_v1::ActiveShard>("account-v1.getActiveShard", route_str, request, min_capacity);
505 #[cfg(feature = "tracing")]
506 let future = future.instrument(tracing::info_span!("account-v1.getActiveShard", route = route_str));
507 #[cfg(feature = "metrics")]
508 let future = metrics::try_timed(future, "account-v1.getActiveShard", route_str);
509 future
510 }
511
512 pub fn get_active_region(&self, route: RegionalRoute, game: &str, puuid: &str)
522 -> impl Future<Output = Result<crate::models::account_v1::AccountRegion>> + 'a
523 {
524 let route_str = route.into();
525 let request = self.base.request(Method::GET, route_str, &format!("/riot/account/v1/region/by-game/{}/by-puuid/{}", game, puuid));
526 let future = self.base.execute_val::<crate::models::account_v1::AccountRegion>("account-v1.getActiveRegion", route_str, request);
527 #[cfg(feature = "tracing")]
528 let future = future.instrument(tracing::info_span!("account-v1.getActiveRegion", route = route_str));
529 #[cfg(feature = "metrics")]
530 let future = metrics::timed(future, "account-v1.getActiveRegion", route_str);
531 future
532 }
533
534 pub fn try_get_active_region(&self, min_capacity: f32, route: RegionalRoute, game: &str, puuid: &str)
546 -> impl Future<Output = TryRequestResult<crate::models::account_v1::AccountRegion>> + 'a
547 {
548 let route_str = route.into();
549 let request = self.base.request(Method::GET, route_str, &format!("/riot/account/v1/region/by-game/{}/by-puuid/{}", game, puuid));
550 let future = self.base.try_execute_val::<crate::models::account_v1::AccountRegion>("account-v1.getActiveRegion", route_str, request, min_capacity);
551 #[cfg(feature = "tracing")]
552 let future = future.instrument(tracing::info_span!("account-v1.getActiveRegion", route = route_str));
553 #[cfg(feature = "metrics")]
554 let future = metrics::try_timed(future, "account-v1.getActiveRegion", route_str);
555 future
556 }
557
558}
559
560#[repr(transparent)]
566pub struct ChampionMasteryV4<'a> {
567 base: &'a RiotApi,
568}
569impl<'a> ChampionMasteryV4<'a> {
570 pub fn get_all_champion_masteries_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str)
579 -> impl Future<Output = Result<Vec<crate::models::champion_mastery_v4::ChampionMastery>>> + 'a
580 {
581 let route_str = route.into();
582 let request = self.base.request(Method::GET, route_str, &format!("/lol/champion-mastery/v4/champion-masteries/by-puuid/{}", encrypted_puuid));
583 let future = self.base.execute_val::<Vec<crate::models::champion_mastery_v4::ChampionMastery>>("champion-mastery-v4.getAllChampionMasteriesByPUUID", route_str, request);
584 #[cfg(feature = "tracing")]
585 let future = future.instrument(tracing::info_span!("champion-mastery-v4.getAllChampionMasteriesByPUUID", route = route_str));
586 #[cfg(feature = "metrics")]
587 let future = metrics::timed(future, "champion-mastery-v4.getAllChampionMasteriesByPUUID", route_str);
588 future
589 }
590
591 pub fn try_get_all_champion_masteries_by_puuid(&self, min_capacity: f32, route: PlatformRoute, encrypted_puuid: &str)
602 -> impl Future<Output = TryRequestResult<Vec<crate::models::champion_mastery_v4::ChampionMastery>>> + 'a
603 {
604 let route_str = route.into();
605 let request = self.base.request(Method::GET, route_str, &format!("/lol/champion-mastery/v4/champion-masteries/by-puuid/{}", encrypted_puuid));
606 let future = self.base.try_execute_val::<Vec<crate::models::champion_mastery_v4::ChampionMastery>>("champion-mastery-v4.getAllChampionMasteriesByPUUID", route_str, request, min_capacity);
607 #[cfg(feature = "tracing")]
608 let future = future.instrument(tracing::info_span!("champion-mastery-v4.getAllChampionMasteriesByPUUID", route = route_str));
609 #[cfg(feature = "metrics")]
610 let future = metrics::try_timed(future, "champion-mastery-v4.getAllChampionMasteriesByPUUID", route_str);
611 future
612 }
613
614 pub fn get_champion_mastery_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str, champion_id: crate::consts::Champion)
624 -> impl Future<Output = Result<crate::models::champion_mastery_v4::ChampionMastery>> + 'a
625 {
626 let route_str = route.into();
627 let request = self.base.request(Method::GET, route_str, &format!("/lol/champion-mastery/v4/champion-masteries/by-puuid/{}/by-champion/{}", encrypted_puuid, champion_id));
628 let future = self.base.execute_val::<crate::models::champion_mastery_v4::ChampionMastery>("champion-mastery-v4.getChampionMasteryByPUUID", route_str, request);
629 #[cfg(feature = "tracing")]
630 let future = future.instrument(tracing::info_span!("champion-mastery-v4.getChampionMasteryByPUUID", route = route_str));
631 #[cfg(feature = "metrics")]
632 let future = metrics::timed(future, "champion-mastery-v4.getChampionMasteryByPUUID", route_str);
633 future
634 }
635
636 pub fn try_get_champion_mastery_by_puuid(&self, min_capacity: f32, route: PlatformRoute, encrypted_puuid: &str, champion_id: crate::consts::Champion)
648 -> impl Future<Output = TryRequestResult<crate::models::champion_mastery_v4::ChampionMastery>> + 'a
649 {
650 let route_str = route.into();
651 let request = self.base.request(Method::GET, route_str, &format!("/lol/champion-mastery/v4/champion-masteries/by-puuid/{}/by-champion/{}", encrypted_puuid, champion_id));
652 let future = self.base.try_execute_val::<crate::models::champion_mastery_v4::ChampionMastery>("champion-mastery-v4.getChampionMasteryByPUUID", route_str, request, min_capacity);
653 #[cfg(feature = "tracing")]
654 let future = future.instrument(tracing::info_span!("champion-mastery-v4.getChampionMasteryByPUUID", route = route_str));
655 #[cfg(feature = "metrics")]
656 let future = metrics::try_timed(future, "champion-mastery-v4.getChampionMasteryByPUUID", route_str);
657 future
658 }
659
660 pub fn get_top_champion_masteries_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str, count: Option<i32>)
670 -> impl Future<Output = Result<Vec<crate::models::champion_mastery_v4::ChampionMastery>>> + 'a
671 {
672 let route_str = route.into();
673 let request = self.base.request(Method::GET, route_str, &format!("/lol/champion-mastery/v4/champion-masteries/by-puuid/{}/top", encrypted_puuid));
674 let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
675 let future = self.base.execute_val::<Vec<crate::models::champion_mastery_v4::ChampionMastery>>("champion-mastery-v4.getTopChampionMasteriesByPUUID", route_str, request);
676 #[cfg(feature = "tracing")]
677 let future = future.instrument(tracing::info_span!("champion-mastery-v4.getTopChampionMasteriesByPUUID", route = route_str));
678 #[cfg(feature = "metrics")]
679 let future = metrics::timed(future, "champion-mastery-v4.getTopChampionMasteriesByPUUID", route_str);
680 future
681 }
682
683 pub fn try_get_top_champion_masteries_by_puuid(&self, min_capacity: f32, route: PlatformRoute, encrypted_puuid: &str, count: Option<i32>)
695 -> impl Future<Output = TryRequestResult<Vec<crate::models::champion_mastery_v4::ChampionMastery>>> + 'a
696 {
697 let route_str = route.into();
698 let request = self.base.request(Method::GET, route_str, &format!("/lol/champion-mastery/v4/champion-masteries/by-puuid/{}/top", encrypted_puuid));
699 let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
700 let future = self.base.try_execute_val::<Vec<crate::models::champion_mastery_v4::ChampionMastery>>("champion-mastery-v4.getTopChampionMasteriesByPUUID", route_str, request, min_capacity);
701 #[cfg(feature = "tracing")]
702 let future = future.instrument(tracing::info_span!("champion-mastery-v4.getTopChampionMasteriesByPUUID", route = route_str));
703 #[cfg(feature = "metrics")]
704 let future = metrics::try_timed(future, "champion-mastery-v4.getTopChampionMasteriesByPUUID", route_str);
705 future
706 }
707
708 pub fn get_champion_mastery_score_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str)
717 -> impl Future<Output = Result<i32>> + 'a
718 {
719 let route_str = route.into();
720 let request = self.base.request(Method::GET, route_str, &format!("/lol/champion-mastery/v4/scores/by-puuid/{}", encrypted_puuid));
721 let future = self.base.execute_val::<i32>("champion-mastery-v4.getChampionMasteryScoreByPUUID", route_str, request);
722 #[cfg(feature = "tracing")]
723 let future = future.instrument(tracing::info_span!("champion-mastery-v4.getChampionMasteryScoreByPUUID", route = route_str));
724 #[cfg(feature = "metrics")]
725 let future = metrics::timed(future, "champion-mastery-v4.getChampionMasteryScoreByPUUID", route_str);
726 future
727 }
728
729 pub fn try_get_champion_mastery_score_by_puuid(&self, min_capacity: f32, route: PlatformRoute, encrypted_puuid: &str)
740 -> impl Future<Output = TryRequestResult<i32>> + 'a
741 {
742 let route_str = route.into();
743 let request = self.base.request(Method::GET, route_str, &format!("/lol/champion-mastery/v4/scores/by-puuid/{}", encrypted_puuid));
744 let future = self.base.try_execute_val::<i32>("champion-mastery-v4.getChampionMasteryScoreByPUUID", route_str, request, min_capacity);
745 #[cfg(feature = "tracing")]
746 let future = future.instrument(tracing::info_span!("champion-mastery-v4.getChampionMasteryScoreByPUUID", route = route_str));
747 #[cfg(feature = "metrics")]
748 let future = metrics::try_timed(future, "champion-mastery-v4.getChampionMasteryScoreByPUUID", route_str);
749 future
750 }
751
752}
753
754#[repr(transparent)]
760pub struct ChampionV3<'a> {
761 base: &'a RiotApi,
762}
763impl<'a> ChampionV3<'a> {
764 pub fn get_champion_info(&self, route: PlatformRoute)
772 -> impl Future<Output = Result<crate::models::champion_v3::ChampionInfo>> + 'a
773 {
774 let route_str = route.into();
775 let request = self.base.request(Method::GET, route_str, "/lol/platform/v3/champion-rotations");
776 let future = self.base.execute_val::<crate::models::champion_v3::ChampionInfo>("champion-v3.getChampionInfo", route_str, request);
777 #[cfg(feature = "tracing")]
778 let future = future.instrument(tracing::info_span!("champion-v3.getChampionInfo", route = route_str));
779 #[cfg(feature = "metrics")]
780 let future = metrics::timed(future, "champion-v3.getChampionInfo", route_str);
781 future
782 }
783
784 pub fn try_get_champion_info(&self, min_capacity: f32, route: PlatformRoute)
794 -> impl Future<Output = TryRequestResult<crate::models::champion_v3::ChampionInfo>> + 'a
795 {
796 let route_str = route.into();
797 let request = self.base.request(Method::GET, route_str, "/lol/platform/v3/champion-rotations");
798 let future = self.base.try_execute_val::<crate::models::champion_v3::ChampionInfo>("champion-v3.getChampionInfo", route_str, request, min_capacity);
799 #[cfg(feature = "tracing")]
800 let future = future.instrument(tracing::info_span!("champion-v3.getChampionInfo", route = route_str));
801 #[cfg(feature = "metrics")]
802 let future = metrics::try_timed(future, "champion-v3.getChampionInfo", route_str);
803 future
804 }
805
806}
807
808#[repr(transparent)]
814pub struct ClashV1<'a> {
815 base: &'a RiotApi,
816}
817impl<'a> ClashV1<'a> {
818 pub fn get_players_by_puuid(&self, route: PlatformRoute, puuid: &str)
829 -> impl Future<Output = Result<Vec<crate::models::clash_v1::Player>>> + 'a
830 {
831 let route_str = route.into();
832 let request = self.base.request(Method::GET, route_str, &format!("/lol/clash/v1/players/by-puuid/{}", puuid));
833 let future = self.base.execute_val::<Vec<crate::models::clash_v1::Player>>("clash-v1.getPlayersByPUUID", route_str, request);
834 #[cfg(feature = "tracing")]
835 let future = future.instrument(tracing::info_span!("clash-v1.getPlayersByPUUID", route = route_str));
836 #[cfg(feature = "metrics")]
837 let future = metrics::timed(future, "clash-v1.getPlayersByPUUID", route_str);
838 future
839 }
840
841 pub fn try_get_players_by_puuid(&self, min_capacity: f32, route: PlatformRoute, puuid: &str)
852 -> impl Future<Output = TryRequestResult<Vec<crate::models::clash_v1::Player>>> + 'a
853 {
854 let route_str = route.into();
855 let request = self.base.request(Method::GET, route_str, &format!("/lol/clash/v1/players/by-puuid/{}", puuid));
856 let future = self.base.try_execute_val::<Vec<crate::models::clash_v1::Player>>("clash-v1.getPlayersByPUUID", route_str, request, min_capacity);
857 #[cfg(feature = "tracing")]
858 let future = future.instrument(tracing::info_span!("clash-v1.getPlayersByPUUID", route = route_str));
859 #[cfg(feature = "metrics")]
860 let future = metrics::try_timed(future, "clash-v1.getPlayersByPUUID", route_str);
861 future
862 }
863
864 pub fn get_team_by_id(&self, route: PlatformRoute, team_id: &str)
873 -> impl Future<Output = Result<Option<crate::models::clash_v1::Team>>> + 'a
874 {
875 let route_str = route.into();
876 let request = self.base.request(Method::GET, route_str, &format!("/lol/clash/v1/teams/{}", team_id));
877 let future = self.base.execute_opt::<crate::models::clash_v1::Team>("clash-v1.getTeamById", route_str, request);
878 #[cfg(feature = "tracing")]
879 let future = future.instrument(tracing::info_span!("clash-v1.getTeamById", route = route_str));
880 #[cfg(feature = "metrics")]
881 let future = metrics::timed(future, "clash-v1.getTeamById", route_str);
882 future
883 }
884
885 pub fn try_get_team_by_id(&self, min_capacity: f32, route: PlatformRoute, team_id: &str)
896 -> impl Future<Output = TryRequestResult<Option<crate::models::clash_v1::Team>>> + 'a
897 {
898 let route_str = route.into();
899 let request = self.base.request(Method::GET, route_str, &format!("/lol/clash/v1/teams/{}", team_id));
900 let future = self.base.try_execute_opt::<crate::models::clash_v1::Team>("clash-v1.getTeamById", route_str, request, min_capacity);
901 #[cfg(feature = "tracing")]
902 let future = future.instrument(tracing::info_span!("clash-v1.getTeamById", route = route_str));
903 #[cfg(feature = "metrics")]
904 let future = metrics::try_timed(future, "clash-v1.getTeamById", route_str);
905 future
906 }
907
908 pub fn get_tournaments(&self, route: PlatformRoute)
916 -> impl Future<Output = Result<Vec<crate::models::clash_v1::Tournament>>> + 'a
917 {
918 let route_str = route.into();
919 let request = self.base.request(Method::GET, route_str, "/lol/clash/v1/tournaments");
920 let future = self.base.execute_val::<Vec<crate::models::clash_v1::Tournament>>("clash-v1.getTournaments", route_str, request);
921 #[cfg(feature = "tracing")]
922 let future = future.instrument(tracing::info_span!("clash-v1.getTournaments", route = route_str));
923 #[cfg(feature = "metrics")]
924 let future = metrics::timed(future, "clash-v1.getTournaments", route_str);
925 future
926 }
927
928 pub fn try_get_tournaments(&self, min_capacity: f32, route: PlatformRoute)
938 -> impl Future<Output = TryRequestResult<Vec<crate::models::clash_v1::Tournament>>> + 'a
939 {
940 let route_str = route.into();
941 let request = self.base.request(Method::GET, route_str, "/lol/clash/v1/tournaments");
942 let future = self.base.try_execute_val::<Vec<crate::models::clash_v1::Tournament>>("clash-v1.getTournaments", route_str, request, min_capacity);
943 #[cfg(feature = "tracing")]
944 let future = future.instrument(tracing::info_span!("clash-v1.getTournaments", route = route_str));
945 #[cfg(feature = "metrics")]
946 let future = metrics::try_timed(future, "clash-v1.getTournaments", route_str);
947 future
948 }
949
950 pub fn get_tournament_by_team(&self, route: PlatformRoute, team_id: &str)
959 -> impl Future<Output = Result<Option<crate::models::clash_v1::Tournament>>> + 'a
960 {
961 let route_str = route.into();
962 let request = self.base.request(Method::GET, route_str, &format!("/lol/clash/v1/tournaments/by-team/{}", team_id));
963 let future = self.base.execute_opt::<crate::models::clash_v1::Tournament>("clash-v1.getTournamentByTeam", route_str, request);
964 #[cfg(feature = "tracing")]
965 let future = future.instrument(tracing::info_span!("clash-v1.getTournamentByTeam", route = route_str));
966 #[cfg(feature = "metrics")]
967 let future = metrics::timed(future, "clash-v1.getTournamentByTeam", route_str);
968 future
969 }
970
971 pub fn try_get_tournament_by_team(&self, min_capacity: f32, route: PlatformRoute, team_id: &str)
982 -> impl Future<Output = TryRequestResult<Option<crate::models::clash_v1::Tournament>>> + 'a
983 {
984 let route_str = route.into();
985 let request = self.base.request(Method::GET, route_str, &format!("/lol/clash/v1/tournaments/by-team/{}", team_id));
986 let future = self.base.try_execute_opt::<crate::models::clash_v1::Tournament>("clash-v1.getTournamentByTeam", route_str, request, min_capacity);
987 #[cfg(feature = "tracing")]
988 let future = future.instrument(tracing::info_span!("clash-v1.getTournamentByTeam", route = route_str));
989 #[cfg(feature = "metrics")]
990 let future = metrics::try_timed(future, "clash-v1.getTournamentByTeam", route_str);
991 future
992 }
993
994 pub fn get_tournament_by_id(&self, route: PlatformRoute, tournament_id: i32)
1003 -> impl Future<Output = Result<Option<crate::models::clash_v1::Tournament>>> + 'a
1004 {
1005 let route_str = route.into();
1006 let request = self.base.request(Method::GET, route_str, &format!("/lol/clash/v1/tournaments/{}", tournament_id));
1007 let future = self.base.execute_opt::<crate::models::clash_v1::Tournament>("clash-v1.getTournamentById", route_str, request);
1008 #[cfg(feature = "tracing")]
1009 let future = future.instrument(tracing::info_span!("clash-v1.getTournamentById", route = route_str));
1010 #[cfg(feature = "metrics")]
1011 let future = metrics::timed(future, "clash-v1.getTournamentById", route_str);
1012 future
1013 }
1014
1015 pub fn try_get_tournament_by_id(&self, min_capacity: f32, route: PlatformRoute, tournament_id: i32)
1026 -> impl Future<Output = TryRequestResult<Option<crate::models::clash_v1::Tournament>>> + 'a
1027 {
1028 let route_str = route.into();
1029 let request = self.base.request(Method::GET, route_str, &format!("/lol/clash/v1/tournaments/{}", tournament_id));
1030 let future = self.base.try_execute_opt::<crate::models::clash_v1::Tournament>("clash-v1.getTournamentById", route_str, request, min_capacity);
1031 #[cfg(feature = "tracing")]
1032 let future = future.instrument(tracing::info_span!("clash-v1.getTournamentById", route = route_str));
1033 #[cfg(feature = "metrics")]
1034 let future = metrics::try_timed(future, "clash-v1.getTournamentById", route_str);
1035 future
1036 }
1037
1038}
1039
1040#[repr(transparent)]
1046pub struct LeagueExpV4<'a> {
1047 base: &'a RiotApi,
1048}
1049impl<'a> LeagueExpV4<'a> {
1050 pub fn get_league_entries(&self, route: PlatformRoute, queue: crate::consts::QueueType, tier: crate::consts::Tier, division: crate::consts::Division, page: Option<i32>)
1062 -> impl Future<Output = Result<Option<Vec<crate::models::league_exp_v4::LeagueEntry>>>> + 'a
1063 {
1064 let route_str = route.into();
1065 let request = self.base.request(Method::GET, route_str, &format!("/lol/league-exp/v4/entries/{}/{}/{}", queue, tier, division));
1066 let request = if let Some(page) = page { request.query(&[ ("page", page) ]) } else { request };
1067 let future = self.base.execute_opt::<Vec<crate::models::league_exp_v4::LeagueEntry>>("league-exp-v4.getLeagueEntries", route_str, request);
1068 #[cfg(feature = "tracing")]
1069 let future = future.instrument(tracing::info_span!("league-exp-v4.getLeagueEntries", route = route_str));
1070 #[cfg(feature = "metrics")]
1071 let future = metrics::timed(future, "league-exp-v4.getLeagueEntries", route_str);
1072 future
1073 }
1074
1075 pub fn try_get_league_entries(&self, min_capacity: f32, route: PlatformRoute, queue: crate::consts::QueueType, tier: crate::consts::Tier, division: crate::consts::Division, page: Option<i32>)
1089 -> impl Future<Output = TryRequestResult<Option<Vec<crate::models::league_exp_v4::LeagueEntry>>>> + 'a
1090 {
1091 let route_str = route.into();
1092 let request = self.base.request(Method::GET, route_str, &format!("/lol/league-exp/v4/entries/{}/{}/{}", queue, tier, division));
1093 let request = if let Some(page) = page { request.query(&[ ("page", page) ]) } else { request };
1094 let future = self.base.try_execute_opt::<Vec<crate::models::league_exp_v4::LeagueEntry>>("league-exp-v4.getLeagueEntries", route_str, request, min_capacity);
1095 #[cfg(feature = "tracing")]
1096 let future = future.instrument(tracing::info_span!("league-exp-v4.getLeagueEntries", route = route_str));
1097 #[cfg(feature = "metrics")]
1098 let future = metrics::try_timed(future, "league-exp-v4.getLeagueEntries", route_str);
1099 future
1100 }
1101
1102}
1103
1104#[repr(transparent)]
1110pub struct LeagueV4<'a> {
1111 base: &'a RiotApi,
1112}
1113impl<'a> LeagueV4<'a> {
1114 pub fn get_challenger_league(&self, route: PlatformRoute, queue: crate::consts::QueueType)
1123 -> impl Future<Output = Result<crate::models::league_v4::LeagueList>> + 'a
1124 {
1125 let route_str = route.into();
1126 let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/challengerleagues/by-queue/{}", queue));
1127 let future = self.base.execute_val::<crate::models::league_v4::LeagueList>("league-v4.getChallengerLeague", route_str, request);
1128 #[cfg(feature = "tracing")]
1129 let future = future.instrument(tracing::info_span!("league-v4.getChallengerLeague", route = route_str));
1130 #[cfg(feature = "metrics")]
1131 let future = metrics::timed(future, "league-v4.getChallengerLeague", route_str);
1132 future
1133 }
1134
1135 pub fn try_get_challenger_league(&self, min_capacity: f32, route: PlatformRoute, queue: crate::consts::QueueType)
1146 -> impl Future<Output = TryRequestResult<crate::models::league_v4::LeagueList>> + 'a
1147 {
1148 let route_str = route.into();
1149 let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/challengerleagues/by-queue/{}", queue));
1150 let future = self.base.try_execute_val::<crate::models::league_v4::LeagueList>("league-v4.getChallengerLeague", route_str, request, min_capacity);
1151 #[cfg(feature = "tracing")]
1152 let future = future.instrument(tracing::info_span!("league-v4.getChallengerLeague", route = route_str));
1153 #[cfg(feature = "metrics")]
1154 let future = metrics::try_timed(future, "league-v4.getChallengerLeague", route_str);
1155 future
1156 }
1157
1158 pub fn get_league_entries_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str)
1167 -> impl Future<Output = Result<Vec<crate::models::league_v4::LeagueEntry>>> + 'a
1168 {
1169 let route_str = route.into();
1170 let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/entries/by-puuid/{}", encrypted_puuid));
1171 let future = self.base.execute_val::<Vec<crate::models::league_v4::LeagueEntry>>("league-v4.getLeagueEntriesByPUUID", route_str, request);
1172 #[cfg(feature = "tracing")]
1173 let future = future.instrument(tracing::info_span!("league-v4.getLeagueEntriesByPUUID", route = route_str));
1174 #[cfg(feature = "metrics")]
1175 let future = metrics::timed(future, "league-v4.getLeagueEntriesByPUUID", route_str);
1176 future
1177 }
1178
1179 pub fn try_get_league_entries_by_puuid(&self, min_capacity: f32, route: PlatformRoute, encrypted_puuid: &str)
1190 -> impl Future<Output = TryRequestResult<Vec<crate::models::league_v4::LeagueEntry>>> + 'a
1191 {
1192 let route_str = route.into();
1193 let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/entries/by-puuid/{}", encrypted_puuid));
1194 let future = self.base.try_execute_val::<Vec<crate::models::league_v4::LeagueEntry>>("league-v4.getLeagueEntriesByPUUID", route_str, request, min_capacity);
1195 #[cfg(feature = "tracing")]
1196 let future = future.instrument(tracing::info_span!("league-v4.getLeagueEntriesByPUUID", route = route_str));
1197 #[cfg(feature = "metrics")]
1198 let future = metrics::try_timed(future, "league-v4.getLeagueEntriesByPUUID", route_str);
1199 future
1200 }
1201
1202 pub fn get_league_entries(&self, route: PlatformRoute, queue: crate::consts::QueueType, tier: crate::consts::Tier, division: crate::consts::Division, page: Option<i32>)
1214 -> impl Future<Output = Result<Option<Vec<crate::models::league_v4::LeagueEntry>>>> + 'a
1215 {
1216 let route_str = route.into();
1217 let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/entries/{}/{}/{}", queue, tier, division));
1218 let request = if let Some(page) = page { request.query(&[ ("page", page) ]) } else { request };
1219 let future = self.base.execute_opt::<Vec<crate::models::league_v4::LeagueEntry>>("league-v4.getLeagueEntries", route_str, request);
1220 #[cfg(feature = "tracing")]
1221 let future = future.instrument(tracing::info_span!("league-v4.getLeagueEntries", route = route_str));
1222 #[cfg(feature = "metrics")]
1223 let future = metrics::timed(future, "league-v4.getLeagueEntries", route_str);
1224 future
1225 }
1226
1227 pub fn try_get_league_entries(&self, min_capacity: f32, route: PlatformRoute, queue: crate::consts::QueueType, tier: crate::consts::Tier, division: crate::consts::Division, page: Option<i32>)
1241 -> impl Future<Output = TryRequestResult<Option<Vec<crate::models::league_v4::LeagueEntry>>>> + 'a
1242 {
1243 let route_str = route.into();
1244 let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/entries/{}/{}/{}", queue, tier, division));
1245 let request = if let Some(page) = page { request.query(&[ ("page", page) ]) } else { request };
1246 let future = self.base.try_execute_opt::<Vec<crate::models::league_v4::LeagueEntry>>("league-v4.getLeagueEntries", route_str, request, min_capacity);
1247 #[cfg(feature = "tracing")]
1248 let future = future.instrument(tracing::info_span!("league-v4.getLeagueEntries", route = route_str));
1249 #[cfg(feature = "metrics")]
1250 let future = metrics::try_timed(future, "league-v4.getLeagueEntries", route_str);
1251 future
1252 }
1253
1254 pub fn get_grandmaster_league(&self, route: PlatformRoute, queue: crate::consts::QueueType)
1263 -> impl Future<Output = Result<crate::models::league_v4::LeagueList>> + 'a
1264 {
1265 let route_str = route.into();
1266 let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/grandmasterleagues/by-queue/{}", queue));
1267 let future = self.base.execute_val::<crate::models::league_v4::LeagueList>("league-v4.getGrandmasterLeague", route_str, request);
1268 #[cfg(feature = "tracing")]
1269 let future = future.instrument(tracing::info_span!("league-v4.getGrandmasterLeague", route = route_str));
1270 #[cfg(feature = "metrics")]
1271 let future = metrics::timed(future, "league-v4.getGrandmasterLeague", route_str);
1272 future
1273 }
1274
1275 pub fn try_get_grandmaster_league(&self, min_capacity: f32, route: PlatformRoute, queue: crate::consts::QueueType)
1286 -> impl Future<Output = TryRequestResult<crate::models::league_v4::LeagueList>> + 'a
1287 {
1288 let route_str = route.into();
1289 let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/grandmasterleagues/by-queue/{}", queue));
1290 let future = self.base.try_execute_val::<crate::models::league_v4::LeagueList>("league-v4.getGrandmasterLeague", route_str, request, min_capacity);
1291 #[cfg(feature = "tracing")]
1292 let future = future.instrument(tracing::info_span!("league-v4.getGrandmasterLeague", route = route_str));
1293 #[cfg(feature = "metrics")]
1294 let future = metrics::try_timed(future, "league-v4.getGrandmasterLeague", route_str);
1295 future
1296 }
1297
1298 pub fn get_league_by_id(&self, route: PlatformRoute, league_id: &str)
1307 -> impl Future<Output = Result<Option<crate::models::league_v4::LeagueList>>> + 'a
1308 {
1309 let route_str = route.into();
1310 let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/leagues/{}", league_id));
1311 let future = self.base.execute_opt::<crate::models::league_v4::LeagueList>("league-v4.getLeagueById", route_str, request);
1312 #[cfg(feature = "tracing")]
1313 let future = future.instrument(tracing::info_span!("league-v4.getLeagueById", route = route_str));
1314 #[cfg(feature = "metrics")]
1315 let future = metrics::timed(future, "league-v4.getLeagueById", route_str);
1316 future
1317 }
1318
1319 pub fn try_get_league_by_id(&self, min_capacity: f32, route: PlatformRoute, league_id: &str)
1330 -> impl Future<Output = TryRequestResult<Option<crate::models::league_v4::LeagueList>>> + 'a
1331 {
1332 let route_str = route.into();
1333 let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/leagues/{}", league_id));
1334 let future = self.base.try_execute_opt::<crate::models::league_v4::LeagueList>("league-v4.getLeagueById", route_str, request, min_capacity);
1335 #[cfg(feature = "tracing")]
1336 let future = future.instrument(tracing::info_span!("league-v4.getLeagueById", route = route_str));
1337 #[cfg(feature = "metrics")]
1338 let future = metrics::try_timed(future, "league-v4.getLeagueById", route_str);
1339 future
1340 }
1341
1342 pub fn get_master_league(&self, route: PlatformRoute, queue: crate::consts::QueueType)
1351 -> impl Future<Output = Result<crate::models::league_v4::LeagueList>> + 'a
1352 {
1353 let route_str = route.into();
1354 let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/masterleagues/by-queue/{}", queue));
1355 let future = self.base.execute_val::<crate::models::league_v4::LeagueList>("league-v4.getMasterLeague", route_str, request);
1356 #[cfg(feature = "tracing")]
1357 let future = future.instrument(tracing::info_span!("league-v4.getMasterLeague", route = route_str));
1358 #[cfg(feature = "metrics")]
1359 let future = metrics::timed(future, "league-v4.getMasterLeague", route_str);
1360 future
1361 }
1362
1363 pub fn try_get_master_league(&self, min_capacity: f32, route: PlatformRoute, queue: crate::consts::QueueType)
1374 -> impl Future<Output = TryRequestResult<crate::models::league_v4::LeagueList>> + 'a
1375 {
1376 let route_str = route.into();
1377 let request = self.base.request(Method::GET, route_str, &format!("/lol/league/v4/masterleagues/by-queue/{}", queue));
1378 let future = self.base.try_execute_val::<crate::models::league_v4::LeagueList>("league-v4.getMasterLeague", route_str, request, min_capacity);
1379 #[cfg(feature = "tracing")]
1380 let future = future.instrument(tracing::info_span!("league-v4.getMasterLeague", route = route_str));
1381 #[cfg(feature = "metrics")]
1382 let future = metrics::try_timed(future, "league-v4.getMasterLeague", route_str);
1383 future
1384 }
1385
1386}
1387
1388#[repr(transparent)]
1394pub struct LolChallengesV1<'a> {
1395 base: &'a RiotApi,
1396}
1397impl<'a> LolChallengesV1<'a> {
1398 pub fn get_all_challenge_configs(&self, route: PlatformRoute)
1406 -> impl Future<Output = Result<Vec<crate::models::lol_challenges_v1::ChallengeConfigInfo>>> + 'a
1407 {
1408 let route_str = route.into();
1409 let request = self.base.request(Method::GET, route_str, "/lol/challenges/v1/challenges/config");
1410 let future = self.base.execute_val::<Vec<crate::models::lol_challenges_v1::ChallengeConfigInfo>>("lol-challenges-v1.getAllChallengeConfigs", route_str, request);
1411 #[cfg(feature = "tracing")]
1412 let future = future.instrument(tracing::info_span!("lol-challenges-v1.getAllChallengeConfigs", route = route_str));
1413 #[cfg(feature = "metrics")]
1414 let future = metrics::timed(future, "lol-challenges-v1.getAllChallengeConfigs", route_str);
1415 future
1416 }
1417
1418 pub fn try_get_all_challenge_configs(&self, min_capacity: f32, route: PlatformRoute)
1428 -> impl Future<Output = TryRequestResult<Vec<crate::models::lol_challenges_v1::ChallengeConfigInfo>>> + 'a
1429 {
1430 let route_str = route.into();
1431 let request = self.base.request(Method::GET, route_str, "/lol/challenges/v1/challenges/config");
1432 let future = self.base.try_execute_val::<Vec<crate::models::lol_challenges_v1::ChallengeConfigInfo>>("lol-challenges-v1.getAllChallengeConfigs", route_str, request, min_capacity);
1433 #[cfg(feature = "tracing")]
1434 let future = future.instrument(tracing::info_span!("lol-challenges-v1.getAllChallengeConfigs", route = route_str));
1435 #[cfg(feature = "metrics")]
1436 let future = metrics::try_timed(future, "lol-challenges-v1.getAllChallengeConfigs", route_str);
1437 future
1438 }
1439
1440 pub fn get_all_challenge_percentiles(&self, route: PlatformRoute)
1448 -> impl Future<Output = Result<std::collections::HashMap<i64, std::collections::HashMap<crate::consts::Tier, f64>>>> + 'a
1449 {
1450 let route_str = route.into();
1451 let request = self.base.request(Method::GET, route_str, "/lol/challenges/v1/challenges/percentiles");
1452 let future = self.base.execute_val::<std::collections::HashMap<i64, std::collections::HashMap<crate::consts::Tier, f64>>>("lol-challenges-v1.getAllChallengePercentiles", route_str, request);
1453 #[cfg(feature = "tracing")]
1454 let future = future.instrument(tracing::info_span!("lol-challenges-v1.getAllChallengePercentiles", route = route_str));
1455 #[cfg(feature = "metrics")]
1456 let future = metrics::timed(future, "lol-challenges-v1.getAllChallengePercentiles", route_str);
1457 future
1458 }
1459
1460 pub fn try_get_all_challenge_percentiles(&self, min_capacity: f32, route: PlatformRoute)
1470 -> impl Future<Output = TryRequestResult<std::collections::HashMap<i64, std::collections::HashMap<crate::consts::Tier, f64>>>> + 'a
1471 {
1472 let route_str = route.into();
1473 let request = self.base.request(Method::GET, route_str, "/lol/challenges/v1/challenges/percentiles");
1474 let future = self.base.try_execute_val::<std::collections::HashMap<i64, std::collections::HashMap<crate::consts::Tier, f64>>>("lol-challenges-v1.getAllChallengePercentiles", route_str, request, min_capacity);
1475 #[cfg(feature = "tracing")]
1476 let future = future.instrument(tracing::info_span!("lol-challenges-v1.getAllChallengePercentiles", route = route_str));
1477 #[cfg(feature = "metrics")]
1478 let future = metrics::try_timed(future, "lol-challenges-v1.getAllChallengePercentiles", route_str);
1479 future
1480 }
1481
1482 pub fn get_challenge_configs(&self, route: PlatformRoute, challenge_id: i64)
1491 -> impl Future<Output = Result<Option<crate::models::lol_challenges_v1::ChallengeConfigInfo>>> + 'a
1492 {
1493 let route_str = route.into();
1494 let request = self.base.request(Method::GET, route_str, &format!("/lol/challenges/v1/challenges/{}/config", challenge_id));
1495 let future = self.base.execute_opt::<crate::models::lol_challenges_v1::ChallengeConfigInfo>("lol-challenges-v1.getChallengeConfigs", route_str, request);
1496 #[cfg(feature = "tracing")]
1497 let future = future.instrument(tracing::info_span!("lol-challenges-v1.getChallengeConfigs", route = route_str));
1498 #[cfg(feature = "metrics")]
1499 let future = metrics::timed(future, "lol-challenges-v1.getChallengeConfigs", route_str);
1500 future
1501 }
1502
1503 pub fn try_get_challenge_configs(&self, min_capacity: f32, route: PlatformRoute, challenge_id: i64)
1514 -> impl Future<Output = TryRequestResult<Option<crate::models::lol_challenges_v1::ChallengeConfigInfo>>> + 'a
1515 {
1516 let route_str = route.into();
1517 let request = self.base.request(Method::GET, route_str, &format!("/lol/challenges/v1/challenges/{}/config", challenge_id));
1518 let future = self.base.try_execute_opt::<crate::models::lol_challenges_v1::ChallengeConfigInfo>("lol-challenges-v1.getChallengeConfigs", route_str, request, min_capacity);
1519 #[cfg(feature = "tracing")]
1520 let future = future.instrument(tracing::info_span!("lol-challenges-v1.getChallengeConfigs", route = route_str));
1521 #[cfg(feature = "metrics")]
1522 let future = metrics::try_timed(future, "lol-challenges-v1.getChallengeConfigs", route_str);
1523 future
1524 }
1525
1526 pub fn get_challenge_leaderboards(&self, route: PlatformRoute, challenge_id: i64, level: crate::consts::Tier, limit: Option<i32>)
1537 -> impl Future<Output = Result<Option<Vec<crate::models::lol_challenges_v1::ApexPlayerInfo>>>> + 'a
1538 {
1539 let route_str = route.into();
1540 let request = self.base.request(Method::GET, route_str, &format!("/lol/challenges/v1/challenges/{}/leaderboards/by-level/{}", challenge_id, level));
1541 let request = if let Some(limit) = limit { request.query(&[ ("limit", limit) ]) } else { request };
1542 let future = self.base.execute_opt::<Vec<crate::models::lol_challenges_v1::ApexPlayerInfo>>("lol-challenges-v1.getChallengeLeaderboards", route_str, request);
1543 #[cfg(feature = "tracing")]
1544 let future = future.instrument(tracing::info_span!("lol-challenges-v1.getChallengeLeaderboards", route = route_str));
1545 #[cfg(feature = "metrics")]
1546 let future = metrics::timed(future, "lol-challenges-v1.getChallengeLeaderboards", route_str);
1547 future
1548 }
1549
1550 pub fn try_get_challenge_leaderboards(&self, min_capacity: f32, route: PlatformRoute, challenge_id: i64, level: crate::consts::Tier, limit: Option<i32>)
1563 -> impl Future<Output = TryRequestResult<Option<Vec<crate::models::lol_challenges_v1::ApexPlayerInfo>>>> + 'a
1564 {
1565 let route_str = route.into();
1566 let request = self.base.request(Method::GET, route_str, &format!("/lol/challenges/v1/challenges/{}/leaderboards/by-level/{}", challenge_id, level));
1567 let request = if let Some(limit) = limit { request.query(&[ ("limit", limit) ]) } else { request };
1568 let future = self.base.try_execute_opt::<Vec<crate::models::lol_challenges_v1::ApexPlayerInfo>>("lol-challenges-v1.getChallengeLeaderboards", route_str, request, min_capacity);
1569 #[cfg(feature = "tracing")]
1570 let future = future.instrument(tracing::info_span!("lol-challenges-v1.getChallengeLeaderboards", route = route_str));
1571 #[cfg(feature = "metrics")]
1572 let future = metrics::try_timed(future, "lol-challenges-v1.getChallengeLeaderboards", route_str);
1573 future
1574 }
1575
1576 pub fn get_challenge_percentiles(&self, route: PlatformRoute, challenge_id: i64)
1585 -> impl Future<Output = Result<Option<std::collections::HashMap<crate::consts::Tier, f64>>>> + 'a
1586 {
1587 let route_str = route.into();
1588 let request = self.base.request(Method::GET, route_str, &format!("/lol/challenges/v1/challenges/{}/percentiles", challenge_id));
1589 let future = self.base.execute_opt::<std::collections::HashMap<crate::consts::Tier, f64>>("lol-challenges-v1.getChallengePercentiles", route_str, request);
1590 #[cfg(feature = "tracing")]
1591 let future = future.instrument(tracing::info_span!("lol-challenges-v1.getChallengePercentiles", route = route_str));
1592 #[cfg(feature = "metrics")]
1593 let future = metrics::timed(future, "lol-challenges-v1.getChallengePercentiles", route_str);
1594 future
1595 }
1596
1597 pub fn try_get_challenge_percentiles(&self, min_capacity: f32, route: PlatformRoute, challenge_id: i64)
1608 -> impl Future<Output = TryRequestResult<Option<std::collections::HashMap<crate::consts::Tier, f64>>>> + 'a
1609 {
1610 let route_str = route.into();
1611 let request = self.base.request(Method::GET, route_str, &format!("/lol/challenges/v1/challenges/{}/percentiles", challenge_id));
1612 let future = self.base.try_execute_opt::<std::collections::HashMap<crate::consts::Tier, f64>>("lol-challenges-v1.getChallengePercentiles", route_str, request, min_capacity);
1613 #[cfg(feature = "tracing")]
1614 let future = future.instrument(tracing::info_span!("lol-challenges-v1.getChallengePercentiles", route = route_str));
1615 #[cfg(feature = "metrics")]
1616 let future = metrics::try_timed(future, "lol-challenges-v1.getChallengePercentiles", route_str);
1617 future
1618 }
1619
1620 pub fn get_player_data(&self, route: PlatformRoute, puuid: &str)
1629 -> impl Future<Output = Result<crate::models::lol_challenges_v1::PlayerInfo>> + 'a
1630 {
1631 let route_str = route.into();
1632 let request = self.base.request(Method::GET, route_str, &format!("/lol/challenges/v1/player-data/{}", puuid));
1633 let future = self.base.execute_val::<crate::models::lol_challenges_v1::PlayerInfo>("lol-challenges-v1.getPlayerData", route_str, request);
1634 #[cfg(feature = "tracing")]
1635 let future = future.instrument(tracing::info_span!("lol-challenges-v1.getPlayerData", route = route_str));
1636 #[cfg(feature = "metrics")]
1637 let future = metrics::timed(future, "lol-challenges-v1.getPlayerData", route_str);
1638 future
1639 }
1640
1641 pub fn try_get_player_data(&self, min_capacity: f32, route: PlatformRoute, puuid: &str)
1652 -> impl Future<Output = TryRequestResult<crate::models::lol_challenges_v1::PlayerInfo>> + 'a
1653 {
1654 let route_str = route.into();
1655 let request = self.base.request(Method::GET, route_str, &format!("/lol/challenges/v1/player-data/{}", puuid));
1656 let future = self.base.try_execute_val::<crate::models::lol_challenges_v1::PlayerInfo>("lol-challenges-v1.getPlayerData", route_str, request, min_capacity);
1657 #[cfg(feature = "tracing")]
1658 let future = future.instrument(tracing::info_span!("lol-challenges-v1.getPlayerData", route = route_str));
1659 #[cfg(feature = "metrics")]
1660 let future = metrics::try_timed(future, "lol-challenges-v1.getPlayerData", route_str);
1661 future
1662 }
1663
1664}
1665
1666#[repr(transparent)]
1672pub struct LolRsoMatchV1<'a> {
1673 base: &'a RiotApi,
1674}
1675impl<'a> LolRsoMatchV1<'a> {
1676 pub fn get_match_ids(&self, route: RegionalRoute, access_token: impl std::fmt::Display, count: Option<i32>, end_time: Option<i64>, queue: Option<i32>, start: Option<i32>, start_time: Option<i64>, r#type: Option<&str>)
1694 -> impl Future<Output = Result<Vec<String>>> + 'a
1695 {
1696 let route_str = route.into();
1697 let request = self.base.request(Method::GET, route_str, "/lol/rso-match/v1/matches/ids");
1698 let mut request = request.bearer_auth(access_token);
1699 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
1700 let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
1701 let request = if let Some(end_time) = end_time { request.query(&[ ("endTime", end_time) ]) } else { request };
1702 let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
1703 let request = if let Some(start) = start { request.query(&[ ("start", start) ]) } else { request };
1704 let request = if let Some(start_time) = start_time { request.query(&[ ("startTime", start_time) ]) } else { request };
1705 let request = if let Some(r#type) = r#type { request.query(&[ ("type", r#type) ]) } else { request };
1706 let future = self.base.execute_val::<Vec<String>>("lol-rso-match-v1.getMatchIds", route_str, request);
1707 #[cfg(feature = "tracing")]
1708 let future = future.instrument(tracing::info_span!("lol-rso-match-v1.getMatchIds", route = route_str));
1709 #[cfg(feature = "metrics")]
1710 let future = metrics::timed(future, "lol-rso-match-v1.getMatchIds", route_str);
1711 future
1712 }
1713
1714 pub fn try_get_match_ids(&self, min_capacity: f32, route: RegionalRoute, access_token: impl std::fmt::Display, count: Option<i32>, end_time: Option<i64>, queue: Option<i32>, start: Option<i32>, start_time: Option<i64>, r#type: Option<&str>)
1734 -> impl Future<Output = TryRequestResult<Vec<String>>> + 'a
1735 {
1736 let route_str = route.into();
1737 let request = self.base.request(Method::GET, route_str, "/lol/rso-match/v1/matches/ids");
1738 let mut request = request.bearer_auth(access_token);
1739 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
1740 let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
1741 let request = if let Some(end_time) = end_time { request.query(&[ ("endTime", end_time) ]) } else { request };
1742 let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
1743 let request = if let Some(start) = start { request.query(&[ ("start", start) ]) } else { request };
1744 let request = if let Some(start_time) = start_time { request.query(&[ ("startTime", start_time) ]) } else { request };
1745 let request = if let Some(r#type) = r#type { request.query(&[ ("type", r#type) ]) } else { request };
1746 let future = self.base.try_execute_val::<Vec<String>>("lol-rso-match-v1.getMatchIds", route_str, request, min_capacity);
1747 #[cfg(feature = "tracing")]
1748 let future = future.instrument(tracing::info_span!("lol-rso-match-v1.getMatchIds", route = route_str));
1749 #[cfg(feature = "metrics")]
1750 let future = metrics::try_timed(future, "lol-rso-match-v1.getMatchIds", route_str);
1751 future
1752 }
1753
1754 pub fn get_match(&self, route: RegionalRoute, access_token: impl std::fmt::Display, match_id: &str)
1767 -> impl Future<Output = Result<crate::models::match_v5::Match>> + 'a
1768 {
1769 let route_str = route.into();
1770 let request = self.base.request(Method::GET, route_str, &format!("/lol/rso-match/v1/matches/{}", match_id));
1771 let mut request = request.bearer_auth(access_token);
1772 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
1773 let future = self.base.execute_val::<crate::models::match_v5::Match>("lol-rso-match-v1.getMatch", route_str, request);
1774 #[cfg(feature = "tracing")]
1775 let future = future.instrument(tracing::info_span!("lol-rso-match-v1.getMatch", route = route_str));
1776 #[cfg(feature = "metrics")]
1777 let future = metrics::timed(future, "lol-rso-match-v1.getMatch", route_str);
1778 future
1779 }
1780
1781 pub fn try_get_match(&self, min_capacity: f32, route: RegionalRoute, access_token: impl std::fmt::Display, match_id: &str)
1796 -> impl Future<Output = TryRequestResult<crate::models::match_v5::Match>> + 'a
1797 {
1798 let route_str = route.into();
1799 let request = self.base.request(Method::GET, route_str, &format!("/lol/rso-match/v1/matches/{}", match_id));
1800 let mut request = request.bearer_auth(access_token);
1801 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
1802 let future = self.base.try_execute_val::<crate::models::match_v5::Match>("lol-rso-match-v1.getMatch", route_str, request, min_capacity);
1803 #[cfg(feature = "tracing")]
1804 let future = future.instrument(tracing::info_span!("lol-rso-match-v1.getMatch", route = route_str));
1805 #[cfg(feature = "metrics")]
1806 let future = metrics::try_timed(future, "lol-rso-match-v1.getMatch", route_str);
1807 future
1808 }
1809
1810 pub fn get_timeline(&self, route: RegionalRoute, access_token: impl std::fmt::Display, match_id: &str)
1823 -> impl Future<Output = Result<crate::models::match_v5::Timeline>> + 'a
1824 {
1825 let route_str = route.into();
1826 let request = self.base.request(Method::GET, route_str, &format!("/lol/rso-match/v1/matches/{}/timeline", match_id));
1827 let mut request = request.bearer_auth(access_token);
1828 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
1829 let future = self.base.execute_val::<crate::models::match_v5::Timeline>("lol-rso-match-v1.getTimeline", route_str, request);
1830 #[cfg(feature = "tracing")]
1831 let future = future.instrument(tracing::info_span!("lol-rso-match-v1.getTimeline", route = route_str));
1832 #[cfg(feature = "metrics")]
1833 let future = metrics::timed(future, "lol-rso-match-v1.getTimeline", route_str);
1834 future
1835 }
1836
1837 pub fn try_get_timeline(&self, min_capacity: f32, route: RegionalRoute, access_token: impl std::fmt::Display, match_id: &str)
1852 -> impl Future<Output = TryRequestResult<crate::models::match_v5::Timeline>> + 'a
1853 {
1854 let route_str = route.into();
1855 let request = self.base.request(Method::GET, route_str, &format!("/lol/rso-match/v1/matches/{}/timeline", match_id));
1856 let mut request = request.bearer_auth(access_token);
1857 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
1858 let future = self.base.try_execute_val::<crate::models::match_v5::Timeline>("lol-rso-match-v1.getTimeline", route_str, request, min_capacity);
1859 #[cfg(feature = "tracing")]
1860 let future = future.instrument(tracing::info_span!("lol-rso-match-v1.getTimeline", route = route_str));
1861 #[cfg(feature = "metrics")]
1862 let future = metrics::try_timed(future, "lol-rso-match-v1.getTimeline", route_str);
1863 future
1864 }
1865
1866}
1867
1868#[repr(transparent)]
1874pub struct LolStatusV4<'a> {
1875 base: &'a RiotApi,
1876}
1877impl<'a> LolStatusV4<'a> {
1878 pub fn get_platform_data(&self, route: PlatformRoute)
1886 -> impl Future<Output = Result<crate::models::lol_status_v4::PlatformData>> + 'a
1887 {
1888 let route_str = route.into();
1889 let request = self.base.request(Method::GET, route_str, "/lol/status/v4/platform-data");
1890 let future = self.base.execute_val::<crate::models::lol_status_v4::PlatformData>("lol-status-v4.getPlatformData", route_str, request);
1891 #[cfg(feature = "tracing")]
1892 let future = future.instrument(tracing::info_span!("lol-status-v4.getPlatformData", route = route_str));
1893 #[cfg(feature = "metrics")]
1894 let future = metrics::timed(future, "lol-status-v4.getPlatformData", route_str);
1895 future
1896 }
1897
1898 pub fn try_get_platform_data(&self, min_capacity: f32, route: PlatformRoute)
1908 -> impl Future<Output = TryRequestResult<crate::models::lol_status_v4::PlatformData>> + 'a
1909 {
1910 let route_str = route.into();
1911 let request = self.base.request(Method::GET, route_str, "/lol/status/v4/platform-data");
1912 let future = self.base.try_execute_val::<crate::models::lol_status_v4::PlatformData>("lol-status-v4.getPlatformData", route_str, request, min_capacity);
1913 #[cfg(feature = "tracing")]
1914 let future = future.instrument(tracing::info_span!("lol-status-v4.getPlatformData", route = route_str));
1915 #[cfg(feature = "metrics")]
1916 let future = metrics::try_timed(future, "lol-status-v4.getPlatformData", route_str);
1917 future
1918 }
1919
1920}
1921
1922#[repr(transparent)]
1928pub struct LorDeckV1<'a> {
1929 base: &'a RiotApi,
1930}
1931impl<'a> LorDeckV1<'a> {
1932 pub fn get_decks(&self, route: RegionalRoute, access_token: impl std::fmt::Display)
1944 -> impl Future<Output = Result<Vec<crate::models::lor_deck_v1::Deck>>> + 'a
1945 {
1946 let route_str = route.into();
1947 let request = self.base.request(Method::GET, route_str, "/lor/deck/v1/decks/me");
1948 let mut request = request.bearer_auth(access_token);
1949 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
1950 let future = self.base.execute_val::<Vec<crate::models::lor_deck_v1::Deck>>("lor-deck-v1.getDecks", route_str, request);
1951 #[cfg(feature = "tracing")]
1952 let future = future.instrument(tracing::info_span!("lor-deck-v1.getDecks", route = route_str));
1953 #[cfg(feature = "metrics")]
1954 let future = metrics::timed(future, "lor-deck-v1.getDecks", route_str);
1955 future
1956 }
1957
1958 pub fn try_get_decks(&self, min_capacity: f32, route: RegionalRoute, access_token: impl std::fmt::Display)
1972 -> impl Future<Output = TryRequestResult<Vec<crate::models::lor_deck_v1::Deck>>> + 'a
1973 {
1974 let route_str = route.into();
1975 let request = self.base.request(Method::GET, route_str, "/lor/deck/v1/decks/me");
1976 let mut request = request.bearer_auth(access_token);
1977 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
1978 let future = self.base.try_execute_val::<Vec<crate::models::lor_deck_v1::Deck>>("lor-deck-v1.getDecks", route_str, request, min_capacity);
1979 #[cfg(feature = "tracing")]
1980 let future = future.instrument(tracing::info_span!("lor-deck-v1.getDecks", route = route_str));
1981 #[cfg(feature = "metrics")]
1982 let future = metrics::try_timed(future, "lor-deck-v1.getDecks", route_str);
1983 future
1984 }
1985
1986 pub fn create_deck(&self, route: RegionalRoute, access_token: impl std::fmt::Display, body: &crate::models::lor_deck_v1::NewDeck)
1998 -> impl Future<Output = Result<String>> + 'a
1999 {
2000 let route_str = route.into();
2001 let request = self.base.request(Method::POST, route_str, "/lor/deck/v1/decks/me");
2002 let mut request = request.bearer_auth(access_token);
2003 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
2004 let request = request
2005 .body(serde_json::ser::to_vec(body).unwrap())
2006 .header(reqwest::header::CONTENT_TYPE, "application/json");
2007 let future = self.base.execute_val::<String>("lor-deck-v1.createDeck", route_str, request);
2008 #[cfg(feature = "tracing")]
2009 let future = future.instrument(tracing::info_span!("lor-deck-v1.createDeck", route = route_str));
2010 #[cfg(feature = "metrics")]
2011 let future = metrics::timed(future, "lor-deck-v1.createDeck", route_str);
2012 future
2013 }
2014
2015 pub fn try_create_deck(&self, min_capacity: f32, route: RegionalRoute, access_token: impl std::fmt::Display, body: &crate::models::lor_deck_v1::NewDeck)
2029 -> impl Future<Output = TryRequestResult<String>> + 'a
2030 {
2031 let route_str = route.into();
2032 let request = self.base.request(Method::POST, route_str, "/lor/deck/v1/decks/me");
2033 let mut request = request.bearer_auth(access_token);
2034 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
2035 let request = request.body(serde_json::ser::to_vec(body).unwrap());
2036 let future = self.base.try_execute_val::<String>("lor-deck-v1.createDeck", route_str, request, min_capacity);
2037 #[cfg(feature = "tracing")]
2038 let future = future.instrument(tracing::info_span!("lor-deck-v1.createDeck", route = route_str));
2039 #[cfg(feature = "metrics")]
2040 let future = metrics::try_timed(future, "lor-deck-v1.createDeck", route_str);
2041 future
2042 }
2043
2044}
2045
2046#[repr(transparent)]
2052pub struct LorInventoryV1<'a> {
2053 base: &'a RiotApi,
2054}
2055impl<'a> LorInventoryV1<'a> {
2056 pub fn get_cards(&self, route: RegionalRoute, access_token: impl std::fmt::Display)
2068 -> impl Future<Output = Result<Vec<crate::models::lor_inventory_v1::Card>>> + 'a
2069 {
2070 let route_str = route.into();
2071 let request = self.base.request(Method::GET, route_str, "/lor/inventory/v1/cards/me");
2072 let mut request = request.bearer_auth(access_token);
2073 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
2074 let future = self.base.execute_val::<Vec<crate::models::lor_inventory_v1::Card>>("lor-inventory-v1.getCards", route_str, request);
2075 #[cfg(feature = "tracing")]
2076 let future = future.instrument(tracing::info_span!("lor-inventory-v1.getCards", route = route_str));
2077 #[cfg(feature = "metrics")]
2078 let future = metrics::timed(future, "lor-inventory-v1.getCards", route_str);
2079 future
2080 }
2081
2082 pub fn try_get_cards(&self, min_capacity: f32, route: RegionalRoute, access_token: impl std::fmt::Display)
2096 -> impl Future<Output = TryRequestResult<Vec<crate::models::lor_inventory_v1::Card>>> + 'a
2097 {
2098 let route_str = route.into();
2099 let request = self.base.request(Method::GET, route_str, "/lor/inventory/v1/cards/me");
2100 let mut request = request.bearer_auth(access_token);
2101 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
2102 let future = self.base.try_execute_val::<Vec<crate::models::lor_inventory_v1::Card>>("lor-inventory-v1.getCards", route_str, request, min_capacity);
2103 #[cfg(feature = "tracing")]
2104 let future = future.instrument(tracing::info_span!("lor-inventory-v1.getCards", route = route_str));
2105 #[cfg(feature = "metrics")]
2106 let future = metrics::try_timed(future, "lor-inventory-v1.getCards", route_str);
2107 future
2108 }
2109
2110}
2111
2112#[repr(transparent)]
2118pub struct LorMatchV1<'a> {
2119 base: &'a RiotApi,
2120}
2121impl<'a> LorMatchV1<'a> {
2122 pub fn get_match_ids_by_puuid(&self, route: RegionalRoute, puuid: &str)
2131 -> impl Future<Output = Result<Vec<String>>> + 'a
2132 {
2133 let route_str = route.into();
2134 let request = self.base.request(Method::GET, route_str, &format!("/lor/match/v1/matches/by-puuid/{}/ids", puuid));
2135 let future = self.base.execute_val::<Vec<String>>("lor-match-v1.getMatchIdsByPUUID", route_str, request);
2136 #[cfg(feature = "tracing")]
2137 let future = future.instrument(tracing::info_span!("lor-match-v1.getMatchIdsByPUUID", route = route_str));
2138 #[cfg(feature = "metrics")]
2139 let future = metrics::timed(future, "lor-match-v1.getMatchIdsByPUUID", route_str);
2140 future
2141 }
2142
2143 pub fn try_get_match_ids_by_puuid(&self, min_capacity: f32, route: RegionalRoute, puuid: &str)
2154 -> impl Future<Output = TryRequestResult<Vec<String>>> + 'a
2155 {
2156 let route_str = route.into();
2157 let request = self.base.request(Method::GET, route_str, &format!("/lor/match/v1/matches/by-puuid/{}/ids", puuid));
2158 let future = self.base.try_execute_val::<Vec<String>>("lor-match-v1.getMatchIdsByPUUID", route_str, request, min_capacity);
2159 #[cfg(feature = "tracing")]
2160 let future = future.instrument(tracing::info_span!("lor-match-v1.getMatchIdsByPUUID", route = route_str));
2161 #[cfg(feature = "metrics")]
2162 let future = metrics::try_timed(future, "lor-match-v1.getMatchIdsByPUUID", route_str);
2163 future
2164 }
2165
2166 pub fn get_match(&self, route: RegionalRoute, match_id: &str)
2175 -> impl Future<Output = Result<crate::models::lor_match_v1::Match>> + 'a
2176 {
2177 let route_str = route.into();
2178 let request = self.base.request(Method::GET, route_str, &format!("/lor/match/v1/matches/{}", match_id));
2179 let future = self.base.execute_val::<crate::models::lor_match_v1::Match>("lor-match-v1.getMatch", route_str, request);
2180 #[cfg(feature = "tracing")]
2181 let future = future.instrument(tracing::info_span!("lor-match-v1.getMatch", route = route_str));
2182 #[cfg(feature = "metrics")]
2183 let future = metrics::timed(future, "lor-match-v1.getMatch", route_str);
2184 future
2185 }
2186
2187 pub fn try_get_match(&self, min_capacity: f32, route: RegionalRoute, match_id: &str)
2198 -> impl Future<Output = TryRequestResult<crate::models::lor_match_v1::Match>> + 'a
2199 {
2200 let route_str = route.into();
2201 let request = self.base.request(Method::GET, route_str, &format!("/lor/match/v1/matches/{}", match_id));
2202 let future = self.base.try_execute_val::<crate::models::lor_match_v1::Match>("lor-match-v1.getMatch", route_str, request, min_capacity);
2203 #[cfg(feature = "tracing")]
2204 let future = future.instrument(tracing::info_span!("lor-match-v1.getMatch", route = route_str));
2205 #[cfg(feature = "metrics")]
2206 let future = metrics::try_timed(future, "lor-match-v1.getMatch", route_str);
2207 future
2208 }
2209
2210}
2211
2212#[repr(transparent)]
2218pub struct LorRankedV1<'a> {
2219 base: &'a RiotApi,
2220}
2221impl<'a> LorRankedV1<'a> {
2222 pub fn get_leaderboards(&self, route: RegionalRoute)
2230 -> impl Future<Output = Result<crate::models::lor_ranked_v1::Leaderboard>> + 'a
2231 {
2232 let route_str = route.into();
2233 let request = self.base.request(Method::GET, route_str, "/lor/ranked/v1/leaderboards");
2234 let future = self.base.execute_val::<crate::models::lor_ranked_v1::Leaderboard>("lor-ranked-v1.getLeaderboards", route_str, request);
2235 #[cfg(feature = "tracing")]
2236 let future = future.instrument(tracing::info_span!("lor-ranked-v1.getLeaderboards", route = route_str));
2237 #[cfg(feature = "metrics")]
2238 let future = metrics::timed(future, "lor-ranked-v1.getLeaderboards", route_str);
2239 future
2240 }
2241
2242 pub fn try_get_leaderboards(&self, min_capacity: f32, route: RegionalRoute)
2252 -> impl Future<Output = TryRequestResult<crate::models::lor_ranked_v1::Leaderboard>> + 'a
2253 {
2254 let route_str = route.into();
2255 let request = self.base.request(Method::GET, route_str, "/lor/ranked/v1/leaderboards");
2256 let future = self.base.try_execute_val::<crate::models::lor_ranked_v1::Leaderboard>("lor-ranked-v1.getLeaderboards", route_str, request, min_capacity);
2257 #[cfg(feature = "tracing")]
2258 let future = future.instrument(tracing::info_span!("lor-ranked-v1.getLeaderboards", route = route_str));
2259 #[cfg(feature = "metrics")]
2260 let future = metrics::try_timed(future, "lor-ranked-v1.getLeaderboards", route_str);
2261 future
2262 }
2263
2264}
2265
2266#[repr(transparent)]
2272pub struct LorStatusV1<'a> {
2273 base: &'a RiotApi,
2274}
2275impl<'a> LorStatusV1<'a> {
2276 pub fn get_platform_data(&self, route: RegionalRoute)
2284 -> impl Future<Output = Result<crate::models::lor_status_v1::PlatformData>> + 'a
2285 {
2286 let route_str = route.into();
2287 let request = self.base.request(Method::GET, route_str, "/lor/status/v1/platform-data");
2288 let future = self.base.execute_val::<crate::models::lor_status_v1::PlatformData>("lor-status-v1.getPlatformData", route_str, request);
2289 #[cfg(feature = "tracing")]
2290 let future = future.instrument(tracing::info_span!("lor-status-v1.getPlatformData", route = route_str));
2291 #[cfg(feature = "metrics")]
2292 let future = metrics::timed(future, "lor-status-v1.getPlatformData", route_str);
2293 future
2294 }
2295
2296 pub fn try_get_platform_data(&self, min_capacity: f32, route: RegionalRoute)
2306 -> impl Future<Output = TryRequestResult<crate::models::lor_status_v1::PlatformData>> + 'a
2307 {
2308 let route_str = route.into();
2309 let request = self.base.request(Method::GET, route_str, "/lor/status/v1/platform-data");
2310 let future = self.base.try_execute_val::<crate::models::lor_status_v1::PlatformData>("lor-status-v1.getPlatformData", route_str, request, min_capacity);
2311 #[cfg(feature = "tracing")]
2312 let future = future.instrument(tracing::info_span!("lor-status-v1.getPlatformData", route = route_str));
2313 #[cfg(feature = "metrics")]
2314 let future = metrics::try_timed(future, "lor-status-v1.getPlatformData", route_str);
2315 future
2316 }
2317
2318}
2319
2320#[repr(transparent)]
2326pub struct MatchV5<'a> {
2327 base: &'a RiotApi,
2328}
2329impl<'a> MatchV5<'a> {
2330 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>)
2345 -> impl Future<Output = Result<Vec<String>>> + 'a
2346 {
2347 let route_str = route.into();
2348 let request = self.base.request(Method::GET, route_str, &format!("/lol/match/v5/matches/by-puuid/{}/ids", puuid));
2349 let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
2350 let request = if let Some(end_time) = end_time { request.query(&[ ("endTime", end_time) ]) } else { request };
2351 let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
2352 let request = if let Some(start_time) = start_time { request.query(&[ ("startTime", start_time) ]) } else { request };
2353 let request = if let Some(start) = start { request.query(&[ ("start", start) ]) } else { request };
2354 let request = if let Some(r#type) = r#type { request.query(&[ ("type", r#type) ]) } else { request };
2355 let future = self.base.execute_val::<Vec<String>>("match-v5.getMatchIdsByPUUID", route_str, request);
2356 #[cfg(feature = "tracing")]
2357 let future = future.instrument(tracing::info_span!("match-v5.getMatchIdsByPUUID", route = route_str));
2358 #[cfg(feature = "metrics")]
2359 let future = metrics::timed(future, "match-v5.getMatchIdsByPUUID", route_str);
2360 future
2361 }
2362
2363 pub fn try_get_match_ids_by_puuid(&self, min_capacity: f32, 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>)
2380 -> impl Future<Output = TryRequestResult<Vec<String>>> + 'a
2381 {
2382 let route_str = route.into();
2383 let request = self.base.request(Method::GET, route_str, &format!("/lol/match/v5/matches/by-puuid/{}/ids", puuid));
2384 let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
2385 let request = if let Some(end_time) = end_time { request.query(&[ ("endTime", end_time) ]) } else { request };
2386 let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
2387 let request = if let Some(start_time) = start_time { request.query(&[ ("startTime", start_time) ]) } else { request };
2388 let request = if let Some(start) = start { request.query(&[ ("start", start) ]) } else { request };
2389 let request = if let Some(r#type) = r#type { request.query(&[ ("type", r#type) ]) } else { request };
2390 let future = self.base.try_execute_val::<Vec<String>>("match-v5.getMatchIdsByPUUID", route_str, request, min_capacity);
2391 #[cfg(feature = "tracing")]
2392 let future = future.instrument(tracing::info_span!("match-v5.getMatchIdsByPUUID", route = route_str));
2393 #[cfg(feature = "metrics")]
2394 let future = metrics::try_timed(future, "match-v5.getMatchIdsByPUUID", route_str);
2395 future
2396 }
2397
2398 pub fn get_match(&self, route: RegionalRoute, match_id: &str)
2407 -> impl Future<Output = Result<Option<crate::models::match_v5::Match>>> + 'a
2408 {
2409 let route_str = route.into();
2410 let request = self.base.request(Method::GET, route_str, &format!("/lol/match/v5/matches/{}", match_id));
2411 let future = self.base.execute_opt::<crate::models::match_v5::Match>("match-v5.getMatch", route_str, request);
2412 #[cfg(feature = "tracing")]
2413 let future = future.instrument(tracing::info_span!("match-v5.getMatch", route = route_str));
2414 #[cfg(feature = "metrics")]
2415 let future = metrics::timed(future, "match-v5.getMatch", route_str);
2416 future
2417 }
2418
2419 pub fn try_get_match(&self, min_capacity: f32, route: RegionalRoute, match_id: &str)
2430 -> impl Future<Output = TryRequestResult<Option<crate::models::match_v5::Match>>> + 'a
2431 {
2432 let route_str = route.into();
2433 let request = self.base.request(Method::GET, route_str, &format!("/lol/match/v5/matches/{}", match_id));
2434 let future = self.base.try_execute_opt::<crate::models::match_v5::Match>("match-v5.getMatch", route_str, request, min_capacity);
2435 #[cfg(feature = "tracing")]
2436 let future = future.instrument(tracing::info_span!("match-v5.getMatch", route = route_str));
2437 #[cfg(feature = "metrics")]
2438 let future = metrics::try_timed(future, "match-v5.getMatch", route_str);
2439 future
2440 }
2441
2442 pub fn get_timeline(&self, route: RegionalRoute, match_id: &str)
2451 -> impl Future<Output = Result<Option<crate::models::match_v5::Timeline>>> + 'a
2452 {
2453 let route_str = route.into();
2454 let request = self.base.request(Method::GET, route_str, &format!("/lol/match/v5/matches/{}/timeline", match_id));
2455 let future = self.base.execute_opt::<crate::models::match_v5::Timeline>("match-v5.getTimeline", route_str, request);
2456 #[cfg(feature = "tracing")]
2457 let future = future.instrument(tracing::info_span!("match-v5.getTimeline", route = route_str));
2458 #[cfg(feature = "metrics")]
2459 let future = metrics::timed(future, "match-v5.getTimeline", route_str);
2460 future
2461 }
2462
2463 pub fn try_get_timeline(&self, min_capacity: f32, route: RegionalRoute, match_id: &str)
2474 -> impl Future<Output = TryRequestResult<Option<crate::models::match_v5::Timeline>>> + 'a
2475 {
2476 let route_str = route.into();
2477 let request = self.base.request(Method::GET, route_str, &format!("/lol/match/v5/matches/{}/timeline", match_id));
2478 let future = self.base.try_execute_opt::<crate::models::match_v5::Timeline>("match-v5.getTimeline", route_str, request, min_capacity);
2479 #[cfg(feature = "tracing")]
2480 let future = future.instrument(tracing::info_span!("match-v5.getTimeline", route = route_str));
2481 #[cfg(feature = "metrics")]
2482 let future = metrics::try_timed(future, "match-v5.getTimeline", route_str);
2483 future
2484 }
2485
2486}
2487
2488#[repr(transparent)]
2494pub struct RiftboundContentV1<'a> {
2495 base: &'a RiotApi,
2496}
2497impl<'a> RiftboundContentV1<'a> {
2498 pub fn get_content(&self, route: RegionalRoute, locale: Option<&str>)
2507 -> impl Future<Output = Result<crate::models::riftbound_content_v1::RiftboundContent>> + 'a
2508 {
2509 let route_str = route.into();
2510 let request = self.base.request(Method::GET, route_str, "/riftbound/content/v1/contents");
2511 let request = if let Some(locale) = locale { request.query(&[ ("locale", locale) ]) } else { request };
2512 let future = self.base.execute_val::<crate::models::riftbound_content_v1::RiftboundContent>("riftbound-content-v1.getContent", route_str, request);
2513 #[cfg(feature = "tracing")]
2514 let future = future.instrument(tracing::info_span!("riftbound-content-v1.getContent", route = route_str));
2515 #[cfg(feature = "metrics")]
2516 let future = metrics::timed(future, "riftbound-content-v1.getContent", route_str);
2517 future
2518 }
2519
2520 pub fn try_get_content(&self, min_capacity: f32, route: RegionalRoute, locale: Option<&str>)
2531 -> impl Future<Output = TryRequestResult<crate::models::riftbound_content_v1::RiftboundContent>> + 'a
2532 {
2533 let route_str = route.into();
2534 let request = self.base.request(Method::GET, route_str, "/riftbound/content/v1/contents");
2535 let request = if let Some(locale) = locale { request.query(&[ ("locale", locale) ]) } else { request };
2536 let future = self.base.try_execute_val::<crate::models::riftbound_content_v1::RiftboundContent>("riftbound-content-v1.getContent", route_str, request, min_capacity);
2537 #[cfg(feature = "tracing")]
2538 let future = future.instrument(tracing::info_span!("riftbound-content-v1.getContent", route = route_str));
2539 #[cfg(feature = "metrics")]
2540 let future = metrics::try_timed(future, "riftbound-content-v1.getContent", route_str);
2541 future
2542 }
2543
2544}
2545
2546#[repr(transparent)]
2552pub struct SpectatorTftV5<'a> {
2553 base: &'a RiotApi,
2554}
2555impl<'a> SpectatorTftV5<'a> {
2556 pub fn get_current_game_info_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str)
2565 -> impl Future<Output = Result<Option<crate::models::spectator_tft_v5::CurrentGameInfo>>> + 'a
2566 {
2567 let route_str = route.into();
2568 let request = self.base.request(Method::GET, route_str, &format!("/lol/spectator/tft/v5/active-games/by-puuid/{}", encrypted_puuid));
2569 let future = self.base.execute_opt::<crate::models::spectator_tft_v5::CurrentGameInfo>("spectator-tft-v5.getCurrentGameInfoByPuuid", route_str, request);
2570 #[cfg(feature = "tracing")]
2571 let future = future.instrument(tracing::info_span!("spectator-tft-v5.getCurrentGameInfoByPuuid", route = route_str));
2572 #[cfg(feature = "metrics")]
2573 let future = metrics::timed(future, "spectator-tft-v5.getCurrentGameInfoByPuuid", route_str);
2574 future
2575 }
2576
2577 pub fn try_get_current_game_info_by_puuid(&self, min_capacity: f32, route: PlatformRoute, encrypted_puuid: &str)
2588 -> impl Future<Output = TryRequestResult<Option<crate::models::spectator_tft_v5::CurrentGameInfo>>> + 'a
2589 {
2590 let route_str = route.into();
2591 let request = self.base.request(Method::GET, route_str, &format!("/lol/spectator/tft/v5/active-games/by-puuid/{}", encrypted_puuid));
2592 let future = self.base.try_execute_opt::<crate::models::spectator_tft_v5::CurrentGameInfo>("spectator-tft-v5.getCurrentGameInfoByPuuid", route_str, request, min_capacity);
2593 #[cfg(feature = "tracing")]
2594 let future = future.instrument(tracing::info_span!("spectator-tft-v5.getCurrentGameInfoByPuuid", route = route_str));
2595 #[cfg(feature = "metrics")]
2596 let future = metrics::try_timed(future, "spectator-tft-v5.getCurrentGameInfoByPuuid", route_str);
2597 future
2598 }
2599
2600 pub fn get_featured_games(&self, route: PlatformRoute)
2608 -> impl Future<Output = Result<crate::models::spectator_tft_v5::FeaturedGames>> + 'a
2609 {
2610 let route_str = route.into();
2611 let request = self.base.request(Method::GET, route_str, "/lol/spectator/tft/v5/featured-games");
2612 let future = self.base.execute_val::<crate::models::spectator_tft_v5::FeaturedGames>("spectator-tft-v5.getFeaturedGames", route_str, request);
2613 #[cfg(feature = "tracing")]
2614 let future = future.instrument(tracing::info_span!("spectator-tft-v5.getFeaturedGames", route = route_str));
2615 #[cfg(feature = "metrics")]
2616 let future = metrics::timed(future, "spectator-tft-v5.getFeaturedGames", route_str);
2617 future
2618 }
2619
2620 pub fn try_get_featured_games(&self, min_capacity: f32, route: PlatformRoute)
2630 -> impl Future<Output = TryRequestResult<crate::models::spectator_tft_v5::FeaturedGames>> + 'a
2631 {
2632 let route_str = route.into();
2633 let request = self.base.request(Method::GET, route_str, "/lol/spectator/tft/v5/featured-games");
2634 let future = self.base.try_execute_val::<crate::models::spectator_tft_v5::FeaturedGames>("spectator-tft-v5.getFeaturedGames", route_str, request, min_capacity);
2635 #[cfg(feature = "tracing")]
2636 let future = future.instrument(tracing::info_span!("spectator-tft-v5.getFeaturedGames", route = route_str));
2637 #[cfg(feature = "metrics")]
2638 let future = metrics::try_timed(future, "spectator-tft-v5.getFeaturedGames", route_str);
2639 future
2640 }
2641
2642}
2643
2644#[repr(transparent)]
2650pub struct SpectatorV5<'a> {
2651 base: &'a RiotApi,
2652}
2653impl<'a> SpectatorV5<'a> {
2654 pub fn get_current_game_info_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str)
2663 -> impl Future<Output = Result<Option<crate::models::spectator_v5::CurrentGameInfo>>> + 'a
2664 {
2665 let route_str = route.into();
2666 let request = self.base.request(Method::GET, route_str, &format!("/lol/spectator/v5/active-games/by-summoner/{}", encrypted_puuid));
2667 let future = self.base.execute_opt::<crate::models::spectator_v5::CurrentGameInfo>("spectator-v5.getCurrentGameInfoByPuuid", route_str, request);
2668 #[cfg(feature = "tracing")]
2669 let future = future.instrument(tracing::info_span!("spectator-v5.getCurrentGameInfoByPuuid", route = route_str));
2670 #[cfg(feature = "metrics")]
2671 let future = metrics::timed(future, "spectator-v5.getCurrentGameInfoByPuuid", route_str);
2672 future
2673 }
2674
2675 pub fn try_get_current_game_info_by_puuid(&self, min_capacity: f32, route: PlatformRoute, encrypted_puuid: &str)
2686 -> impl Future<Output = TryRequestResult<Option<crate::models::spectator_v5::CurrentGameInfo>>> + 'a
2687 {
2688 let route_str = route.into();
2689 let request = self.base.request(Method::GET, route_str, &format!("/lol/spectator/v5/active-games/by-summoner/{}", encrypted_puuid));
2690 let future = self.base.try_execute_opt::<crate::models::spectator_v5::CurrentGameInfo>("spectator-v5.getCurrentGameInfoByPuuid", route_str, request, min_capacity);
2691 #[cfg(feature = "tracing")]
2692 let future = future.instrument(tracing::info_span!("spectator-v5.getCurrentGameInfoByPuuid", route = route_str));
2693 #[cfg(feature = "metrics")]
2694 let future = metrics::try_timed(future, "spectator-v5.getCurrentGameInfoByPuuid", route_str);
2695 future
2696 }
2697
2698 pub fn get_featured_games(&self, route: PlatformRoute)
2706 -> impl Future<Output = Result<crate::models::spectator_v5::FeaturedGames>> + 'a
2707 {
2708 let route_str = route.into();
2709 let request = self.base.request(Method::GET, route_str, "/lol/spectator/v5/featured-games");
2710 let future = self.base.execute_val::<crate::models::spectator_v5::FeaturedGames>("spectator-v5.getFeaturedGames", route_str, request);
2711 #[cfg(feature = "tracing")]
2712 let future = future.instrument(tracing::info_span!("spectator-v5.getFeaturedGames", route = route_str));
2713 #[cfg(feature = "metrics")]
2714 let future = metrics::timed(future, "spectator-v5.getFeaturedGames", route_str);
2715 future
2716 }
2717
2718 pub fn try_get_featured_games(&self, min_capacity: f32, route: PlatformRoute)
2728 -> impl Future<Output = TryRequestResult<crate::models::spectator_v5::FeaturedGames>> + 'a
2729 {
2730 let route_str = route.into();
2731 let request = self.base.request(Method::GET, route_str, "/lol/spectator/v5/featured-games");
2732 let future = self.base.try_execute_val::<crate::models::spectator_v5::FeaturedGames>("spectator-v5.getFeaturedGames", route_str, request, min_capacity);
2733 #[cfg(feature = "tracing")]
2734 let future = future.instrument(tracing::info_span!("spectator-v5.getFeaturedGames", route = route_str));
2735 #[cfg(feature = "metrics")]
2736 let future = metrics::try_timed(future, "spectator-v5.getFeaturedGames", route_str);
2737 future
2738 }
2739
2740}
2741
2742#[repr(transparent)]
2748pub struct SummonerV4<'a> {
2749 base: &'a RiotApi,
2750}
2751impl<'a> SummonerV4<'a> {
2752 pub fn get_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str)
2761 -> impl Future<Output = Result<Option<crate::models::summoner_v4::Summoner>>> + 'a
2762 {
2763 let route_str = route.into();
2764 let request = self.base.request(Method::GET, route_str, &format!("/lol/summoner/v4/summoners/by-puuid/{}", encrypted_puuid));
2765 let future = self.base.execute_opt::<crate::models::summoner_v4::Summoner>("summoner-v4.getByPUUID", route_str, request);
2766 #[cfg(feature = "tracing")]
2767 let future = future.instrument(tracing::info_span!("summoner-v4.getByPUUID", route = route_str));
2768 #[cfg(feature = "metrics")]
2769 let future = metrics::timed(future, "summoner-v4.getByPUUID", route_str);
2770 future
2771 }
2772
2773 pub fn try_get_by_puuid(&self, min_capacity: f32, route: PlatformRoute, encrypted_puuid: &str)
2784 -> impl Future<Output = TryRequestResult<Option<crate::models::summoner_v4::Summoner>>> + 'a
2785 {
2786 let route_str = route.into();
2787 let request = self.base.request(Method::GET, route_str, &format!("/lol/summoner/v4/summoners/by-puuid/{}", encrypted_puuid));
2788 let future = self.base.try_execute_opt::<crate::models::summoner_v4::Summoner>("summoner-v4.getByPUUID", route_str, request, min_capacity);
2789 #[cfg(feature = "tracing")]
2790 let future = future.instrument(tracing::info_span!("summoner-v4.getByPUUID", route = route_str));
2791 #[cfg(feature = "metrics")]
2792 let future = metrics::try_timed(future, "summoner-v4.getByPUUID", route_str);
2793 future
2794 }
2795
2796 pub fn get_by_access_token(&self, route: PlatformRoute, access_token: impl std::fmt::Display)
2808 -> impl Future<Output = Result<crate::models::summoner_v4::Summoner>> + 'a
2809 {
2810 let route_str = route.into();
2811 let request = self.base.request(Method::GET, route_str, "/lol/summoner/v4/summoners/me");
2812 let mut request = request.bearer_auth(access_token);
2813 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
2814 let future = self.base.execute_val::<crate::models::summoner_v4::Summoner>("summoner-v4.getByAccessToken", route_str, request);
2815 #[cfg(feature = "tracing")]
2816 let future = future.instrument(tracing::info_span!("summoner-v4.getByAccessToken", route = route_str));
2817 #[cfg(feature = "metrics")]
2818 let future = metrics::timed(future, "summoner-v4.getByAccessToken", route_str);
2819 future
2820 }
2821
2822 pub fn try_get_by_access_token(&self, min_capacity: f32, route: PlatformRoute, access_token: impl std::fmt::Display)
2836 -> impl Future<Output = TryRequestResult<crate::models::summoner_v4::Summoner>> + 'a
2837 {
2838 let route_str = route.into();
2839 let request = self.base.request(Method::GET, route_str, "/lol/summoner/v4/summoners/me");
2840 let mut request = request.bearer_auth(access_token);
2841 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
2842 let future = self.base.try_execute_val::<crate::models::summoner_v4::Summoner>("summoner-v4.getByAccessToken", route_str, request, min_capacity);
2843 #[cfg(feature = "tracing")]
2844 let future = future.instrument(tracing::info_span!("summoner-v4.getByAccessToken", route = route_str));
2845 #[cfg(feature = "metrics")]
2846 let future = metrics::try_timed(future, "summoner-v4.getByAccessToken", route_str);
2847 future
2848 }
2849
2850}
2851
2852#[repr(transparent)]
2858pub struct TftLeagueV1<'a> {
2859 base: &'a RiotApi,
2860}
2861impl<'a> TftLeagueV1<'a> {
2862 pub fn get_league_entries_by_puuid(&self, route: PlatformRoute, puuid: &str)
2871 -> impl Future<Output = Result<Vec<crate::models::tft_league_v1::LeagueEntry>>> + 'a
2872 {
2873 let route_str = route.into();
2874 let request = self.base.request(Method::GET, route_str, &format!("/tft/league/v1/by-puuid/{}", puuid));
2875 let future = self.base.execute_val::<Vec<crate::models::tft_league_v1::LeagueEntry>>("tft-league-v1.getLeagueEntriesByPUUID", route_str, request);
2876 #[cfg(feature = "tracing")]
2877 let future = future.instrument(tracing::info_span!("tft-league-v1.getLeagueEntriesByPUUID", route = route_str));
2878 #[cfg(feature = "metrics")]
2879 let future = metrics::timed(future, "tft-league-v1.getLeagueEntriesByPUUID", route_str);
2880 future
2881 }
2882
2883 pub fn try_get_league_entries_by_puuid(&self, min_capacity: f32, route: PlatformRoute, puuid: &str)
2894 -> impl Future<Output = TryRequestResult<Vec<crate::models::tft_league_v1::LeagueEntry>>> + 'a
2895 {
2896 let route_str = route.into();
2897 let request = self.base.request(Method::GET, route_str, &format!("/tft/league/v1/by-puuid/{}", puuid));
2898 let future = self.base.try_execute_val::<Vec<crate::models::tft_league_v1::LeagueEntry>>("tft-league-v1.getLeagueEntriesByPUUID", route_str, request, min_capacity);
2899 #[cfg(feature = "tracing")]
2900 let future = future.instrument(tracing::info_span!("tft-league-v1.getLeagueEntriesByPUUID", route = route_str));
2901 #[cfg(feature = "metrics")]
2902 let future = metrics::try_timed(future, "tft-league-v1.getLeagueEntriesByPUUID", route_str);
2903 future
2904 }
2905
2906 pub fn get_challenger_league(&self, route: PlatformRoute, queue: Option<&str>)
2915 -> impl Future<Output = Result<crate::models::tft_league_v1::LeagueList>> + 'a
2916 {
2917 let route_str = route.into();
2918 let request = self.base.request(Method::GET, route_str, "/tft/league/v1/challenger");
2919 let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
2920 let future = self.base.execute_val::<crate::models::tft_league_v1::LeagueList>("tft-league-v1.getChallengerLeague", route_str, request);
2921 #[cfg(feature = "tracing")]
2922 let future = future.instrument(tracing::info_span!("tft-league-v1.getChallengerLeague", route = route_str));
2923 #[cfg(feature = "metrics")]
2924 let future = metrics::timed(future, "tft-league-v1.getChallengerLeague", route_str);
2925 future
2926 }
2927
2928 pub fn try_get_challenger_league(&self, min_capacity: f32, route: PlatformRoute, queue: Option<&str>)
2939 -> impl Future<Output = TryRequestResult<crate::models::tft_league_v1::LeagueList>> + 'a
2940 {
2941 let route_str = route.into();
2942 let request = self.base.request(Method::GET, route_str, "/tft/league/v1/challenger");
2943 let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
2944 let future = self.base.try_execute_val::<crate::models::tft_league_v1::LeagueList>("tft-league-v1.getChallengerLeague", route_str, request, min_capacity);
2945 #[cfg(feature = "tracing")]
2946 let future = future.instrument(tracing::info_span!("tft-league-v1.getChallengerLeague", route = route_str));
2947 #[cfg(feature = "metrics")]
2948 let future = metrics::try_timed(future, "tft-league-v1.getChallengerLeague", route_str);
2949 future
2950 }
2951
2952 pub fn get_league_entries(&self, route: PlatformRoute, tier: crate::consts::Tier, division: &str, page: Option<i32>, queue: Option<&str>)
2964 -> impl Future<Output = Result<Vec<crate::models::tft_league_v1::LeagueEntry>>> + 'a
2965 {
2966 let route_str = route.into();
2967 let request = self.base.request(Method::GET, route_str, &format!("/tft/league/v1/entries/{}/{}", tier, division));
2968 let request = if let Some(page) = page { request.query(&[ ("page", page) ]) } else { request };
2969 let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
2970 let future = self.base.execute_val::<Vec<crate::models::tft_league_v1::LeagueEntry>>("tft-league-v1.getLeagueEntries", route_str, request);
2971 #[cfg(feature = "tracing")]
2972 let future = future.instrument(tracing::info_span!("tft-league-v1.getLeagueEntries", route = route_str));
2973 #[cfg(feature = "metrics")]
2974 let future = metrics::timed(future, "tft-league-v1.getLeagueEntries", route_str);
2975 future
2976 }
2977
2978 pub fn try_get_league_entries(&self, min_capacity: f32, route: PlatformRoute, tier: crate::consts::Tier, division: &str, page: Option<i32>, queue: Option<&str>)
2992 -> impl Future<Output = TryRequestResult<Vec<crate::models::tft_league_v1::LeagueEntry>>> + 'a
2993 {
2994 let route_str = route.into();
2995 let request = self.base.request(Method::GET, route_str, &format!("/tft/league/v1/entries/{}/{}", tier, division));
2996 let request = if let Some(page) = page { request.query(&[ ("page", page) ]) } else { request };
2997 let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
2998 let future = self.base.try_execute_val::<Vec<crate::models::tft_league_v1::LeagueEntry>>("tft-league-v1.getLeagueEntries", route_str, request, min_capacity);
2999 #[cfg(feature = "tracing")]
3000 let future = future.instrument(tracing::info_span!("tft-league-v1.getLeagueEntries", route = route_str));
3001 #[cfg(feature = "metrics")]
3002 let future = metrics::try_timed(future, "tft-league-v1.getLeagueEntries", route_str);
3003 future
3004 }
3005
3006 pub fn get_grandmaster_league(&self, route: PlatformRoute, queue: Option<&str>)
3015 -> impl Future<Output = Result<crate::models::tft_league_v1::LeagueList>> + 'a
3016 {
3017 let route_str = route.into();
3018 let request = self.base.request(Method::GET, route_str, "/tft/league/v1/grandmaster");
3019 let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
3020 let future = self.base.execute_val::<crate::models::tft_league_v1::LeagueList>("tft-league-v1.getGrandmasterLeague", route_str, request);
3021 #[cfg(feature = "tracing")]
3022 let future = future.instrument(tracing::info_span!("tft-league-v1.getGrandmasterLeague", route = route_str));
3023 #[cfg(feature = "metrics")]
3024 let future = metrics::timed(future, "tft-league-v1.getGrandmasterLeague", route_str);
3025 future
3026 }
3027
3028 pub fn try_get_grandmaster_league(&self, min_capacity: f32, route: PlatformRoute, queue: Option<&str>)
3039 -> impl Future<Output = TryRequestResult<crate::models::tft_league_v1::LeagueList>> + 'a
3040 {
3041 let route_str = route.into();
3042 let request = self.base.request(Method::GET, route_str, "/tft/league/v1/grandmaster");
3043 let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
3044 let future = self.base.try_execute_val::<crate::models::tft_league_v1::LeagueList>("tft-league-v1.getGrandmasterLeague", route_str, request, min_capacity);
3045 #[cfg(feature = "tracing")]
3046 let future = future.instrument(tracing::info_span!("tft-league-v1.getGrandmasterLeague", route = route_str));
3047 #[cfg(feature = "metrics")]
3048 let future = metrics::try_timed(future, "tft-league-v1.getGrandmasterLeague", route_str);
3049 future
3050 }
3051
3052 pub fn get_league_by_id(&self, route: PlatformRoute, league_id: &str)
3061 -> impl Future<Output = Result<Option<crate::models::tft_league_v1::LeagueList>>> + 'a
3062 {
3063 let route_str = route.into();
3064 let request = self.base.request(Method::GET, route_str, &format!("/tft/league/v1/leagues/{}", league_id));
3065 let future = self.base.execute_opt::<crate::models::tft_league_v1::LeagueList>("tft-league-v1.getLeagueById", route_str, request);
3066 #[cfg(feature = "tracing")]
3067 let future = future.instrument(tracing::info_span!("tft-league-v1.getLeagueById", route = route_str));
3068 #[cfg(feature = "metrics")]
3069 let future = metrics::timed(future, "tft-league-v1.getLeagueById", route_str);
3070 future
3071 }
3072
3073 pub fn try_get_league_by_id(&self, min_capacity: f32, route: PlatformRoute, league_id: &str)
3084 -> impl Future<Output = TryRequestResult<Option<crate::models::tft_league_v1::LeagueList>>> + 'a
3085 {
3086 let route_str = route.into();
3087 let request = self.base.request(Method::GET, route_str, &format!("/tft/league/v1/leagues/{}", league_id));
3088 let future = self.base.try_execute_opt::<crate::models::tft_league_v1::LeagueList>("tft-league-v1.getLeagueById", route_str, request, min_capacity);
3089 #[cfg(feature = "tracing")]
3090 let future = future.instrument(tracing::info_span!("tft-league-v1.getLeagueById", route = route_str));
3091 #[cfg(feature = "metrics")]
3092 let future = metrics::try_timed(future, "tft-league-v1.getLeagueById", route_str);
3093 future
3094 }
3095
3096 pub fn get_master_league(&self, route: PlatformRoute, queue: Option<&str>)
3105 -> impl Future<Output = Result<crate::models::tft_league_v1::LeagueList>> + 'a
3106 {
3107 let route_str = route.into();
3108 let request = self.base.request(Method::GET, route_str, "/tft/league/v1/master");
3109 let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
3110 let future = self.base.execute_val::<crate::models::tft_league_v1::LeagueList>("tft-league-v1.getMasterLeague", route_str, request);
3111 #[cfg(feature = "tracing")]
3112 let future = future.instrument(tracing::info_span!("tft-league-v1.getMasterLeague", route = route_str));
3113 #[cfg(feature = "metrics")]
3114 let future = metrics::timed(future, "tft-league-v1.getMasterLeague", route_str);
3115 future
3116 }
3117
3118 pub fn try_get_master_league(&self, min_capacity: f32, route: PlatformRoute, queue: Option<&str>)
3129 -> impl Future<Output = TryRequestResult<crate::models::tft_league_v1::LeagueList>> + 'a
3130 {
3131 let route_str = route.into();
3132 let request = self.base.request(Method::GET, route_str, "/tft/league/v1/master");
3133 let request = if let Some(queue) = queue { request.query(&[ ("queue", queue) ]) } else { request };
3134 let future = self.base.try_execute_val::<crate::models::tft_league_v1::LeagueList>("tft-league-v1.getMasterLeague", route_str, request, min_capacity);
3135 #[cfg(feature = "tracing")]
3136 let future = future.instrument(tracing::info_span!("tft-league-v1.getMasterLeague", route = route_str));
3137 #[cfg(feature = "metrics")]
3138 let future = metrics::try_timed(future, "tft-league-v1.getMasterLeague", route_str);
3139 future
3140 }
3141
3142 pub fn get_top_rated_ladder(&self, route: PlatformRoute, queue: crate::consts::QueueType)
3151 -> impl Future<Output = Result<Vec<crate::models::tft_league_v1::TopRatedLadderEntry>>> + 'a
3152 {
3153 let route_str = route.into();
3154 let request = self.base.request(Method::GET, route_str, &format!("/tft/league/v1/rated-ladders/{}/top", queue));
3155 let future = self.base.execute_val::<Vec<crate::models::tft_league_v1::TopRatedLadderEntry>>("tft-league-v1.getTopRatedLadder", route_str, request);
3156 #[cfg(feature = "tracing")]
3157 let future = future.instrument(tracing::info_span!("tft-league-v1.getTopRatedLadder", route = route_str));
3158 #[cfg(feature = "metrics")]
3159 let future = metrics::timed(future, "tft-league-v1.getTopRatedLadder", route_str);
3160 future
3161 }
3162
3163 pub fn try_get_top_rated_ladder(&self, min_capacity: f32, route: PlatformRoute, queue: crate::consts::QueueType)
3174 -> impl Future<Output = TryRequestResult<Vec<crate::models::tft_league_v1::TopRatedLadderEntry>>> + 'a
3175 {
3176 let route_str = route.into();
3177 let request = self.base.request(Method::GET, route_str, &format!("/tft/league/v1/rated-ladders/{}/top", queue));
3178 let future = self.base.try_execute_val::<Vec<crate::models::tft_league_v1::TopRatedLadderEntry>>("tft-league-v1.getTopRatedLadder", route_str, request, min_capacity);
3179 #[cfg(feature = "tracing")]
3180 let future = future.instrument(tracing::info_span!("tft-league-v1.getTopRatedLadder", route = route_str));
3181 #[cfg(feature = "metrics")]
3182 let future = metrics::try_timed(future, "tft-league-v1.getTopRatedLadder", route_str);
3183 future
3184 }
3185
3186}
3187
3188#[repr(transparent)]
3194pub struct TftMatchV1<'a> {
3195 base: &'a RiotApi,
3196}
3197impl<'a> TftMatchV1<'a> {
3198 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>)
3211 -> impl Future<Output = Result<Vec<String>>> + 'a
3212 {
3213 let route_str = route.into();
3214 let request = self.base.request(Method::GET, route_str, &format!("/tft/match/v1/matches/by-puuid/{}/ids", puuid));
3215 let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
3216 let request = if let Some(end_time) = end_time { request.query(&[ ("endTime", end_time) ]) } else { request };
3217 let request = if let Some(start) = start { request.query(&[ ("start", start) ]) } else { request };
3218 let request = if let Some(start_time) = start_time { request.query(&[ ("startTime", start_time) ]) } else { request };
3219 let future = self.base.execute_val::<Vec<String>>("tft-match-v1.getMatchIdsByPUUID", route_str, request);
3220 #[cfg(feature = "tracing")]
3221 let future = future.instrument(tracing::info_span!("tft-match-v1.getMatchIdsByPUUID", route = route_str));
3222 #[cfg(feature = "metrics")]
3223 let future = metrics::timed(future, "tft-match-v1.getMatchIdsByPUUID", route_str);
3224 future
3225 }
3226
3227 pub fn try_get_match_ids_by_puuid(&self, min_capacity: f32, route: RegionalRoute, puuid: &str, count: Option<i32>, end_time: Option<i64>, start: Option<i32>, start_time: Option<i64>)
3242 -> impl Future<Output = TryRequestResult<Vec<String>>> + 'a
3243 {
3244 let route_str = route.into();
3245 let request = self.base.request(Method::GET, route_str, &format!("/tft/match/v1/matches/by-puuid/{}/ids", puuid));
3246 let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
3247 let request = if let Some(end_time) = end_time { request.query(&[ ("endTime", end_time) ]) } else { request };
3248 let request = if let Some(start) = start { request.query(&[ ("start", start) ]) } else { request };
3249 let request = if let Some(start_time) = start_time { request.query(&[ ("startTime", start_time) ]) } else { request };
3250 let future = self.base.try_execute_val::<Vec<String>>("tft-match-v1.getMatchIdsByPUUID", route_str, request, min_capacity);
3251 #[cfg(feature = "tracing")]
3252 let future = future.instrument(tracing::info_span!("tft-match-v1.getMatchIdsByPUUID", route = route_str));
3253 #[cfg(feature = "metrics")]
3254 let future = metrics::try_timed(future, "tft-match-v1.getMatchIdsByPUUID", route_str);
3255 future
3256 }
3257
3258 pub fn get_match(&self, route: RegionalRoute, match_id: &str)
3267 -> impl Future<Output = Result<Option<crate::models::tft_match_v1::Match>>> + 'a
3268 {
3269 let route_str = route.into();
3270 let request = self.base.request(Method::GET, route_str, &format!("/tft/match/v1/matches/{}", match_id));
3271 let future = self.base.execute_opt::<crate::models::tft_match_v1::Match>("tft-match-v1.getMatch", route_str, request);
3272 #[cfg(feature = "tracing")]
3273 let future = future.instrument(tracing::info_span!("tft-match-v1.getMatch", route = route_str));
3274 #[cfg(feature = "metrics")]
3275 let future = metrics::timed(future, "tft-match-v1.getMatch", route_str);
3276 future
3277 }
3278
3279 pub fn try_get_match(&self, min_capacity: f32, route: RegionalRoute, match_id: &str)
3290 -> impl Future<Output = TryRequestResult<Option<crate::models::tft_match_v1::Match>>> + 'a
3291 {
3292 let route_str = route.into();
3293 let request = self.base.request(Method::GET, route_str, &format!("/tft/match/v1/matches/{}", match_id));
3294 let future = self.base.try_execute_opt::<crate::models::tft_match_v1::Match>("tft-match-v1.getMatch", route_str, request, min_capacity);
3295 #[cfg(feature = "tracing")]
3296 let future = future.instrument(tracing::info_span!("tft-match-v1.getMatch", route = route_str));
3297 #[cfg(feature = "metrics")]
3298 let future = metrics::try_timed(future, "tft-match-v1.getMatch", route_str);
3299 future
3300 }
3301
3302}
3303
3304#[repr(transparent)]
3310pub struct TftStatusV1<'a> {
3311 base: &'a RiotApi,
3312}
3313impl<'a> TftStatusV1<'a> {
3314 pub fn get_platform_data(&self, route: PlatformRoute)
3322 -> impl Future<Output = Result<crate::models::tft_status_v1::PlatformData>> + 'a
3323 {
3324 let route_str = route.into();
3325 let request = self.base.request(Method::GET, route_str, "/tft/status/v1/platform-data");
3326 let future = self.base.execute_val::<crate::models::tft_status_v1::PlatformData>("tft-status-v1.getPlatformData", route_str, request);
3327 #[cfg(feature = "tracing")]
3328 let future = future.instrument(tracing::info_span!("tft-status-v1.getPlatformData", route = route_str));
3329 #[cfg(feature = "metrics")]
3330 let future = metrics::timed(future, "tft-status-v1.getPlatformData", route_str);
3331 future
3332 }
3333
3334 pub fn try_get_platform_data(&self, min_capacity: f32, route: PlatformRoute)
3344 -> impl Future<Output = TryRequestResult<crate::models::tft_status_v1::PlatformData>> + 'a
3345 {
3346 let route_str = route.into();
3347 let request = self.base.request(Method::GET, route_str, "/tft/status/v1/platform-data");
3348 let future = self.base.try_execute_val::<crate::models::tft_status_v1::PlatformData>("tft-status-v1.getPlatformData", route_str, request, min_capacity);
3349 #[cfg(feature = "tracing")]
3350 let future = future.instrument(tracing::info_span!("tft-status-v1.getPlatformData", route = route_str));
3351 #[cfg(feature = "metrics")]
3352 let future = metrics::try_timed(future, "tft-status-v1.getPlatformData", route_str);
3353 future
3354 }
3355
3356}
3357
3358#[repr(transparent)]
3364pub struct TftSummonerV1<'a> {
3365 base: &'a RiotApi,
3366}
3367impl<'a> TftSummonerV1<'a> {
3368 pub fn get_by_puuid(&self, route: PlatformRoute, encrypted_puuid: &str)
3377 -> impl Future<Output = Result<crate::models::tft_summoner_v1::Summoner>> + 'a
3378 {
3379 let route_str = route.into();
3380 let request = self.base.request(Method::GET, route_str, &format!("/tft/summoner/v1/summoners/by-puuid/{}", encrypted_puuid));
3381 let future = self.base.execute_val::<crate::models::tft_summoner_v1::Summoner>("tft-summoner-v1.getByPUUID", route_str, request);
3382 #[cfg(feature = "tracing")]
3383 let future = future.instrument(tracing::info_span!("tft-summoner-v1.getByPUUID", route = route_str));
3384 #[cfg(feature = "metrics")]
3385 let future = metrics::timed(future, "tft-summoner-v1.getByPUUID", route_str);
3386 future
3387 }
3388
3389 pub fn try_get_by_puuid(&self, min_capacity: f32, route: PlatformRoute, encrypted_puuid: &str)
3400 -> impl Future<Output = TryRequestResult<crate::models::tft_summoner_v1::Summoner>> + 'a
3401 {
3402 let route_str = route.into();
3403 let request = self.base.request(Method::GET, route_str, &format!("/tft/summoner/v1/summoners/by-puuid/{}", encrypted_puuid));
3404 let future = self.base.try_execute_val::<crate::models::tft_summoner_v1::Summoner>("tft-summoner-v1.getByPUUID", route_str, request, min_capacity);
3405 #[cfg(feature = "tracing")]
3406 let future = future.instrument(tracing::info_span!("tft-summoner-v1.getByPUUID", route = route_str));
3407 #[cfg(feature = "metrics")]
3408 let future = metrics::try_timed(future, "tft-summoner-v1.getByPUUID", route_str);
3409 future
3410 }
3411
3412 pub fn get_by_access_token(&self, route: PlatformRoute, access_token: impl std::fmt::Display)
3424 -> impl Future<Output = Result<crate::models::tft_summoner_v1::Summoner>> + 'a
3425 {
3426 let route_str = route.into();
3427 let request = self.base.request(Method::GET, route_str, "/tft/summoner/v1/summoners/me");
3428 let mut request = request.bearer_auth(access_token);
3429 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
3430 let future = self.base.execute_val::<crate::models::tft_summoner_v1::Summoner>("tft-summoner-v1.getByAccessToken", route_str, request);
3431 #[cfg(feature = "tracing")]
3432 let future = future.instrument(tracing::info_span!("tft-summoner-v1.getByAccessToken", route = route_str));
3433 #[cfg(feature = "metrics")]
3434 let future = metrics::timed(future, "tft-summoner-v1.getByAccessToken", route_str);
3435 future
3436 }
3437
3438 pub fn try_get_by_access_token(&self, min_capacity: f32, route: PlatformRoute, access_token: impl std::fmt::Display)
3452 -> impl Future<Output = TryRequestResult<crate::models::tft_summoner_v1::Summoner>> + 'a
3453 {
3454 let route_str = route.into();
3455 let request = self.base.request(Method::GET, route_str, "/tft/summoner/v1/summoners/me");
3456 let mut request = request.bearer_auth(access_token);
3457 if let Some(clear) = self.base.get_rso_clear_header() { request = request.header(clear, "") }
3458 let future = self.base.try_execute_val::<crate::models::tft_summoner_v1::Summoner>("tft-summoner-v1.getByAccessToken", route_str, request, min_capacity);
3459 #[cfg(feature = "tracing")]
3460 let future = future.instrument(tracing::info_span!("tft-summoner-v1.getByAccessToken", route = route_str));
3461 #[cfg(feature = "metrics")]
3462 let future = metrics::try_timed(future, "tft-summoner-v1.getByAccessToken", route_str);
3463 future
3464 }
3465
3466}
3467
3468#[repr(transparent)]
3474pub struct TournamentStubV5<'a> {
3475 base: &'a RiotApi,
3476}
3477impl<'a> TournamentStubV5<'a> {
3478 pub fn create_tournament_code(&self, route: RegionalRoute, body: &crate::models::tournament_stub_v5::TournamentCodeParametersV5, tournament_id: i64, count: Option<i32>)
3488 -> impl Future<Output = Result<Vec<String>>> + 'a
3489 {
3490 let route_str = route.into();
3491 let request = self.base.request(Method::POST, route_str, "/lol/tournament-stub/v5/codes");
3492 let request = request.query(&[ ("tournamentId", tournament_id) ]);
3493 let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
3494 let request = request
3495 .body(serde_json::ser::to_vec(body).unwrap())
3496 .header(reqwest::header::CONTENT_TYPE, "application/json");
3497 let future = self.base.execute_val::<Vec<String>>("tournament-stub-v5.createTournamentCode", route_str, request);
3498 #[cfg(feature = "tracing")]
3499 let future = future.instrument(tracing::info_span!("tournament-stub-v5.createTournamentCode", route = route_str));
3500 #[cfg(feature = "metrics")]
3501 let future = metrics::timed(future, "tournament-stub-v5.createTournamentCode", route_str);
3502 future
3503 }
3504
3505 pub fn try_create_tournament_code(&self, min_capacity: f32, route: RegionalRoute, body: &crate::models::tournament_stub_v5::TournamentCodeParametersV5, tournament_id: i64, count: Option<i32>)
3517 -> impl Future<Output = TryRequestResult<Vec<String>>> + 'a
3518 {
3519 let route_str = route.into();
3520 let request = self.base.request(Method::POST, route_str, "/lol/tournament-stub/v5/codes");
3521 let request = request.query(&[ ("tournamentId", tournament_id) ]);
3522 let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
3523 let request = request.body(serde_json::ser::to_vec(body).unwrap());
3524 let future = self.base.try_execute_val::<Vec<String>>("tournament-stub-v5.createTournamentCode", route_str, request, min_capacity);
3525 #[cfg(feature = "tracing")]
3526 let future = future.instrument(tracing::info_span!("tournament-stub-v5.createTournamentCode", route = route_str));
3527 #[cfg(feature = "metrics")]
3528 let future = metrics::try_timed(future, "tournament-stub-v5.createTournamentCode", route_str);
3529 future
3530 }
3531
3532 pub fn get_tournament_code(&self, route: RegionalRoute, tournament_code: &str)
3541 -> impl Future<Output = Result<crate::models::tournament_stub_v5::TournamentCodeV5>> + 'a
3542 {
3543 let route_str = route.into();
3544 let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament-stub/v5/codes/{}", tournament_code));
3545 let future = self.base.execute_val::<crate::models::tournament_stub_v5::TournamentCodeV5>("tournament-stub-v5.getTournamentCode", route_str, request);
3546 #[cfg(feature = "tracing")]
3547 let future = future.instrument(tracing::info_span!("tournament-stub-v5.getTournamentCode", route = route_str));
3548 #[cfg(feature = "metrics")]
3549 let future = metrics::timed(future, "tournament-stub-v5.getTournamentCode", route_str);
3550 future
3551 }
3552
3553 pub fn try_get_tournament_code(&self, min_capacity: f32, route: RegionalRoute, tournament_code: &str)
3564 -> impl Future<Output = TryRequestResult<crate::models::tournament_stub_v5::TournamentCodeV5>> + 'a
3565 {
3566 let route_str = route.into();
3567 let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament-stub/v5/codes/{}", tournament_code));
3568 let future = self.base.try_execute_val::<crate::models::tournament_stub_v5::TournamentCodeV5>("tournament-stub-v5.getTournamentCode", route_str, request, min_capacity);
3569 #[cfg(feature = "tracing")]
3570 let future = future.instrument(tracing::info_span!("tournament-stub-v5.getTournamentCode", route = route_str));
3571 #[cfg(feature = "metrics")]
3572 let future = metrics::try_timed(future, "tournament-stub-v5.getTournamentCode", route_str);
3573 future
3574 }
3575
3576 pub fn get_lobby_events_by_code(&self, route: RegionalRoute, tournament_code: &str)
3585 -> impl Future<Output = Result<crate::models::tournament_stub_v5::LobbyEventV5Wrapper>> + 'a
3586 {
3587 let route_str = route.into();
3588 let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament-stub/v5/lobby-events/by-code/{}", tournament_code));
3589 let future = self.base.execute_val::<crate::models::tournament_stub_v5::LobbyEventV5Wrapper>("tournament-stub-v5.getLobbyEventsByCode", route_str, request);
3590 #[cfg(feature = "tracing")]
3591 let future = future.instrument(tracing::info_span!("tournament-stub-v5.getLobbyEventsByCode", route = route_str));
3592 #[cfg(feature = "metrics")]
3593 let future = metrics::timed(future, "tournament-stub-v5.getLobbyEventsByCode", route_str);
3594 future
3595 }
3596
3597 pub fn try_get_lobby_events_by_code(&self, min_capacity: f32, route: RegionalRoute, tournament_code: &str)
3608 -> impl Future<Output = TryRequestResult<crate::models::tournament_stub_v5::LobbyEventV5Wrapper>> + 'a
3609 {
3610 let route_str = route.into();
3611 let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament-stub/v5/lobby-events/by-code/{}", tournament_code));
3612 let future = self.base.try_execute_val::<crate::models::tournament_stub_v5::LobbyEventV5Wrapper>("tournament-stub-v5.getLobbyEventsByCode", route_str, request, min_capacity);
3613 #[cfg(feature = "tracing")]
3614 let future = future.instrument(tracing::info_span!("tournament-stub-v5.getLobbyEventsByCode", route = route_str));
3615 #[cfg(feature = "metrics")]
3616 let future = metrics::try_timed(future, "tournament-stub-v5.getLobbyEventsByCode", route_str);
3617 future
3618 }
3619
3620 pub fn register_provider_data(&self, route: RegionalRoute, body: &crate::models::tournament_stub_v5::ProviderRegistrationParametersV5)
3630 -> impl Future<Output = Result<i32>> + 'a
3631 {
3632 let route_str = route.into();
3633 let request = self.base.request(Method::POST, route_str, "/lol/tournament-stub/v5/providers");
3634 let request = request
3635 .body(serde_json::ser::to_vec(body).unwrap())
3636 .header(reqwest::header::CONTENT_TYPE, "application/json");
3637 let future = self.base.execute_val::<i32>("tournament-stub-v5.registerProviderData", route_str, request);
3638 #[cfg(feature = "tracing")]
3639 let future = future.instrument(tracing::info_span!("tournament-stub-v5.registerProviderData", route = route_str));
3640 #[cfg(feature = "metrics")]
3641 let future = metrics::timed(future, "tournament-stub-v5.registerProviderData", route_str);
3642 future
3643 }
3644
3645 pub fn try_register_provider_data(&self, min_capacity: f32, route: RegionalRoute, body: &crate::models::tournament_stub_v5::ProviderRegistrationParametersV5)
3655 -> impl Future<Output = TryRequestResult<i32>> + 'a
3656 {
3657 let route_str = route.into();
3658 let request = self.base.request(Method::POST, route_str, "/lol/tournament-stub/v5/providers");
3659 let request = request.body(serde_json::ser::to_vec(body).unwrap());
3660 let future = self.base.try_execute_val::<i32>("tournament-stub-v5.registerProviderData", route_str, request, min_capacity);
3661 #[cfg(feature = "tracing")]
3662 let future = future.instrument(tracing::info_span!("tournament-stub-v5.registerProviderData", route = route_str));
3663 #[cfg(feature = "metrics")]
3664 let future = metrics::try_timed(future, "tournament-stub-v5.registerProviderData", route_str);
3665 future
3666 }
3667
3668 pub fn register_tournament(&self, route: RegionalRoute, body: &crate::models::tournament_stub_v5::TournamentRegistrationParametersV5)
3676 -> impl Future<Output = Result<i32>> + 'a
3677 {
3678 let route_str = route.into();
3679 let request = self.base.request(Method::POST, route_str, "/lol/tournament-stub/v5/tournaments");
3680 let request = request
3681 .body(serde_json::ser::to_vec(body).unwrap())
3682 .header(reqwest::header::CONTENT_TYPE, "application/json");
3683 let future = self.base.execute_val::<i32>("tournament-stub-v5.registerTournament", route_str, request);
3684 #[cfg(feature = "tracing")]
3685 let future = future.instrument(tracing::info_span!("tournament-stub-v5.registerTournament", route = route_str));
3686 #[cfg(feature = "metrics")]
3687 let future = metrics::timed(future, "tournament-stub-v5.registerTournament", route_str);
3688 future
3689 }
3690
3691 pub fn try_register_tournament(&self, min_capacity: f32, route: RegionalRoute, body: &crate::models::tournament_stub_v5::TournamentRegistrationParametersV5)
3701 -> impl Future<Output = TryRequestResult<i32>> + 'a
3702 {
3703 let route_str = route.into();
3704 let request = self.base.request(Method::POST, route_str, "/lol/tournament-stub/v5/tournaments");
3705 let request = request.body(serde_json::ser::to_vec(body).unwrap());
3706 let future = self.base.try_execute_val::<i32>("tournament-stub-v5.registerTournament", route_str, request, min_capacity);
3707 #[cfg(feature = "tracing")]
3708 let future = future.instrument(tracing::info_span!("tournament-stub-v5.registerTournament", route = route_str));
3709 #[cfg(feature = "metrics")]
3710 let future = metrics::try_timed(future, "tournament-stub-v5.registerTournament", route_str);
3711 future
3712 }
3713
3714}
3715
3716#[repr(transparent)]
3722pub struct TournamentV5<'a> {
3723 base: &'a RiotApi,
3724}
3725impl<'a> TournamentV5<'a> {
3726 pub fn create_tournament_code(&self, route: RegionalRoute, body: &crate::models::tournament_v5::TournamentCodeParametersV5, tournament_id: i64, count: Option<i32>)
3736 -> impl Future<Output = Result<Vec<String>>> + 'a
3737 {
3738 let route_str = route.into();
3739 let request = self.base.request(Method::POST, route_str, "/lol/tournament/v5/codes");
3740 let request = request.query(&[ ("tournamentId", tournament_id) ]);
3741 let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
3742 let request = request
3743 .body(serde_json::ser::to_vec(body).unwrap())
3744 .header(reqwest::header::CONTENT_TYPE, "application/json");
3745 let future = self.base.execute_val::<Vec<String>>("tournament-v5.createTournamentCode", route_str, request);
3746 #[cfg(feature = "tracing")]
3747 let future = future.instrument(tracing::info_span!("tournament-v5.createTournamentCode", route = route_str));
3748 #[cfg(feature = "metrics")]
3749 let future = metrics::timed(future, "tournament-v5.createTournamentCode", route_str);
3750 future
3751 }
3752
3753 pub fn try_create_tournament_code(&self, min_capacity: f32, route: RegionalRoute, body: &crate::models::tournament_v5::TournamentCodeParametersV5, tournament_id: i64, count: Option<i32>)
3765 -> impl Future<Output = TryRequestResult<Vec<String>>> + 'a
3766 {
3767 let route_str = route.into();
3768 let request = self.base.request(Method::POST, route_str, "/lol/tournament/v5/codes");
3769 let request = request.query(&[ ("tournamentId", tournament_id) ]);
3770 let request = if let Some(count) = count { request.query(&[ ("count", count) ]) } else { request };
3771 let request = request.body(serde_json::ser::to_vec(body).unwrap());
3772 let future = self.base.try_execute_val::<Vec<String>>("tournament-v5.createTournamentCode", route_str, request, min_capacity);
3773 #[cfg(feature = "tracing")]
3774 let future = future.instrument(tracing::info_span!("tournament-v5.createTournamentCode", route = route_str));
3775 #[cfg(feature = "metrics")]
3776 let future = metrics::try_timed(future, "tournament-v5.createTournamentCode", route_str);
3777 future
3778 }
3779
3780 pub fn get_tournament_code(&self, route: RegionalRoute, tournament_code: &str)
3789 -> impl Future<Output = Result<crate::models::tournament_v5::TournamentCodeV5>> + 'a
3790 {
3791 let route_str = route.into();
3792 let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament/v5/codes/{}", tournament_code));
3793 let future = self.base.execute_val::<crate::models::tournament_v5::TournamentCodeV5>("tournament-v5.getTournamentCode", route_str, request);
3794 #[cfg(feature = "tracing")]
3795 let future = future.instrument(tracing::info_span!("tournament-v5.getTournamentCode", route = route_str));
3796 #[cfg(feature = "metrics")]
3797 let future = metrics::timed(future, "tournament-v5.getTournamentCode", route_str);
3798 future
3799 }
3800
3801 pub fn try_get_tournament_code(&self, min_capacity: f32, route: RegionalRoute, tournament_code: &str)
3812 -> impl Future<Output = TryRequestResult<crate::models::tournament_v5::TournamentCodeV5>> + 'a
3813 {
3814 let route_str = route.into();
3815 let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament/v5/codes/{}", tournament_code));
3816 let future = self.base.try_execute_val::<crate::models::tournament_v5::TournamentCodeV5>("tournament-v5.getTournamentCode", route_str, request, min_capacity);
3817 #[cfg(feature = "tracing")]
3818 let future = future.instrument(tracing::info_span!("tournament-v5.getTournamentCode", route = route_str));
3819 #[cfg(feature = "metrics")]
3820 let future = metrics::try_timed(future, "tournament-v5.getTournamentCode", route_str);
3821 future
3822 }
3823
3824 pub fn update_code(&self, route: RegionalRoute, body: &crate::models::tournament_v5::TournamentCodeUpdateParametersV5, tournament_code: &str)
3833 -> impl Future<Output = Result<()>> + 'a
3834 {
3835 let route_str = route.into();
3836 let request = self.base.request(Method::PUT, route_str, &format!("/lol/tournament/v5/codes/{}", tournament_code));
3837 let request = request
3838 .body(serde_json::ser::to_vec(body).unwrap())
3839 .header(reqwest::header::CONTENT_TYPE, "application/json");
3840 let future = self.base.execute("tournament-v5.updateCode", route_str, request);
3841 #[cfg(feature = "tracing")]
3842 let future = future.instrument(tracing::info_span!("tournament-v5.updateCode", route = route_str));
3843 #[cfg(feature = "metrics")]
3844 let future = metrics::timed(future, "tournament-v5.updateCode", route_str);
3845 future
3846 }
3847
3848 pub fn try_update_code(&self, min_capacity: f32, route: RegionalRoute, body: &crate::models::tournament_v5::TournamentCodeUpdateParametersV5, tournament_code: &str)
3859 -> impl Future<Output = TryRequestResult<()>> + 'a
3860 {
3861 let route_str = route.into();
3862 let request = self.base.request(Method::PUT, route_str, &format!("/lol/tournament/v5/codes/{}", tournament_code));
3863 let request = request.body(serde_json::ser::to_vec(body).unwrap());
3864 let future = self.base.try_execute("tournament-v5.updateCode", route_str, request, min_capacity);
3865 #[cfg(feature = "tracing")]
3866 let future = future.instrument(tracing::info_span!("tournament-v5.updateCode", route = route_str));
3867 #[cfg(feature = "metrics")]
3868 let future = metrics::try_timed(future, "tournament-v5.updateCode", route_str);
3869 future
3870 }
3871
3872 pub fn get_games(&self, route: RegionalRoute, tournament_code: &str)
3887 -> impl Future<Output = Result<Vec<crate::models::tournament_v5::TournamentGamesV5>>> + 'a
3888 {
3889 let route_str = route.into();
3890 let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament/v5/games/by-code/{}", tournament_code));
3891 let future = self.base.execute_val::<Vec<crate::models::tournament_v5::TournamentGamesV5>>("tournament-v5.getGames", route_str, request);
3892 #[cfg(feature = "tracing")]
3893 let future = future.instrument(tracing::info_span!("tournament-v5.getGames", route = route_str));
3894 #[cfg(feature = "metrics")]
3895 let future = metrics::timed(future, "tournament-v5.getGames", route_str);
3896 future
3897 }
3898
3899 pub fn try_get_games(&self, min_capacity: f32, route: RegionalRoute, tournament_code: &str)
3910 -> impl Future<Output = TryRequestResult<Vec<crate::models::tournament_v5::TournamentGamesV5>>> + 'a
3911 {
3912 let route_str = route.into();
3913 let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament/v5/games/by-code/{}", tournament_code));
3914 let future = self.base.try_execute_val::<Vec<crate::models::tournament_v5::TournamentGamesV5>>("tournament-v5.getGames", route_str, request, min_capacity);
3915 #[cfg(feature = "tracing")]
3916 let future = future.instrument(tracing::info_span!("tournament-v5.getGames", route = route_str));
3917 #[cfg(feature = "metrics")]
3918 let future = metrics::try_timed(future, "tournament-v5.getGames", route_str);
3919 future
3920 }
3921
3922 pub fn get_lobby_events_by_code(&self, route: RegionalRoute, tournament_code: &str)
3931 -> impl Future<Output = Result<crate::models::tournament_v5::LobbyEventV5Wrapper>> + 'a
3932 {
3933 let route_str = route.into();
3934 let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament/v5/lobby-events/by-code/{}", tournament_code));
3935 let future = self.base.execute_val::<crate::models::tournament_v5::LobbyEventV5Wrapper>("tournament-v5.getLobbyEventsByCode", route_str, request);
3936 #[cfg(feature = "tracing")]
3937 let future = future.instrument(tracing::info_span!("tournament-v5.getLobbyEventsByCode", route = route_str));
3938 #[cfg(feature = "metrics")]
3939 let future = metrics::timed(future, "tournament-v5.getLobbyEventsByCode", route_str);
3940 future
3941 }
3942
3943 pub fn try_get_lobby_events_by_code(&self, min_capacity: f32, route: RegionalRoute, tournament_code: &str)
3954 -> impl Future<Output = TryRequestResult<crate::models::tournament_v5::LobbyEventV5Wrapper>> + 'a
3955 {
3956 let route_str = route.into();
3957 let request = self.base.request(Method::GET, route_str, &format!("/lol/tournament/v5/lobby-events/by-code/{}", tournament_code));
3958 let future = self.base.try_execute_val::<crate::models::tournament_v5::LobbyEventV5Wrapper>("tournament-v5.getLobbyEventsByCode", route_str, request, min_capacity);
3959 #[cfg(feature = "tracing")]
3960 let future = future.instrument(tracing::info_span!("tournament-v5.getLobbyEventsByCode", route = route_str));
3961 #[cfg(feature = "metrics")]
3962 let future = metrics::try_timed(future, "tournament-v5.getLobbyEventsByCode", route_str);
3963 future
3964 }
3965
3966 pub fn register_provider_data(&self, route: RegionalRoute, body: &crate::models::tournament_v5::ProviderRegistrationParametersV5)
3976 -> impl Future<Output = Result<i32>> + 'a
3977 {
3978 let route_str = route.into();
3979 let request = self.base.request(Method::POST, route_str, "/lol/tournament/v5/providers");
3980 let request = request
3981 .body(serde_json::ser::to_vec(body).unwrap())
3982 .header(reqwest::header::CONTENT_TYPE, "application/json");
3983 let future = self.base.execute_val::<i32>("tournament-v5.registerProviderData", route_str, request);
3984 #[cfg(feature = "tracing")]
3985 let future = future.instrument(tracing::info_span!("tournament-v5.registerProviderData", route = route_str));
3986 #[cfg(feature = "metrics")]
3987 let future = metrics::timed(future, "tournament-v5.registerProviderData", route_str);
3988 future
3989 }
3990
3991 pub fn try_register_provider_data(&self, min_capacity: f32, route: RegionalRoute, body: &crate::models::tournament_v5::ProviderRegistrationParametersV5)
4001 -> impl Future<Output = TryRequestResult<i32>> + 'a
4002 {
4003 let route_str = route.into();
4004 let request = self.base.request(Method::POST, route_str, "/lol/tournament/v5/providers");
4005 let request = request.body(serde_json::ser::to_vec(body).unwrap());
4006 let future = self.base.try_execute_val::<i32>("tournament-v5.registerProviderData", route_str, request, min_capacity);
4007 #[cfg(feature = "tracing")]
4008 let future = future.instrument(tracing::info_span!("tournament-v5.registerProviderData", route = route_str));
4009 #[cfg(feature = "metrics")]
4010 let future = metrics::try_timed(future, "tournament-v5.registerProviderData", route_str);
4011 future
4012 }
4013
4014 pub fn register_tournament(&self, route: RegionalRoute, body: &crate::models::tournament_v5::TournamentRegistrationParametersV5)
4022 -> impl Future<Output = Result<i32>> + 'a
4023 {
4024 let route_str = route.into();
4025 let request = self.base.request(Method::POST, route_str, "/lol/tournament/v5/tournaments");
4026 let request = request
4027 .body(serde_json::ser::to_vec(body).unwrap())
4028 .header(reqwest::header::CONTENT_TYPE, "application/json");
4029 let future = self.base.execute_val::<i32>("tournament-v5.registerTournament", route_str, request);
4030 #[cfg(feature = "tracing")]
4031 let future = future.instrument(tracing::info_span!("tournament-v5.registerTournament", route = route_str));
4032 #[cfg(feature = "metrics")]
4033 let future = metrics::timed(future, "tournament-v5.registerTournament", route_str);
4034 future
4035 }
4036
4037 pub fn try_register_tournament(&self, min_capacity: f32, route: RegionalRoute, body: &crate::models::tournament_v5::TournamentRegistrationParametersV5)
4047 -> impl Future<Output = TryRequestResult<i32>> + 'a
4048 {
4049 let route_str = route.into();
4050 let request = self.base.request(Method::POST, route_str, "/lol/tournament/v5/tournaments");
4051 let request = request.body(serde_json::ser::to_vec(body).unwrap());
4052 let future = self.base.try_execute_val::<i32>("tournament-v5.registerTournament", route_str, request, min_capacity);
4053 #[cfg(feature = "tracing")]
4054 let future = future.instrument(tracing::info_span!("tournament-v5.registerTournament", route = route_str));
4055 #[cfg(feature = "metrics")]
4056 let future = metrics::try_timed(future, "tournament-v5.registerTournament", route_str);
4057 future
4058 }
4059
4060}
4061
4062#[repr(transparent)]
4068pub struct ValConsoleMatchV1<'a> {
4069 base: &'a RiotApi,
4070}
4071impl<'a> ValConsoleMatchV1<'a> {
4072 pub fn get_match(&self, route: ValPlatformRoute, match_id: &str)
4081 -> impl Future<Output = Result<Option<crate::models::val_console_match_v1::Match>>> + 'a
4082 {
4083 let route_str = route.into();
4084 let request = self.base.request(Method::GET, route_str, &format!("/val/match/console/v1/matches/{}", match_id));
4085 let future = self.base.execute_opt::<crate::models::val_console_match_v1::Match>("val-console-match-v1.getMatch", route_str, request);
4086 #[cfg(feature = "tracing")]
4087 let future = future.instrument(tracing::info_span!("val-console-match-v1.getMatch", route = route_str));
4088 #[cfg(feature = "metrics")]
4089 let future = metrics::timed(future, "val-console-match-v1.getMatch", route_str);
4090 future
4091 }
4092
4093 pub fn try_get_match(&self, min_capacity: f32, route: ValPlatformRoute, match_id: &str)
4104 -> impl Future<Output = TryRequestResult<Option<crate::models::val_console_match_v1::Match>>> + 'a
4105 {
4106 let route_str = route.into();
4107 let request = self.base.request(Method::GET, route_str, &format!("/val/match/console/v1/matches/{}", match_id));
4108 let future = self.base.try_execute_opt::<crate::models::val_console_match_v1::Match>("val-console-match-v1.getMatch", route_str, request, min_capacity);
4109 #[cfg(feature = "tracing")]
4110 let future = future.instrument(tracing::info_span!("val-console-match-v1.getMatch", route = route_str));
4111 #[cfg(feature = "metrics")]
4112 let future = metrics::try_timed(future, "val-console-match-v1.getMatch", route_str);
4113 future
4114 }
4115
4116 pub fn get_matchlist(&self, route: ValPlatformRoute, puuid: &str, platform_type: &str)
4126 -> impl Future<Output = Result<crate::models::val_console_match_v1::Matchlist>> + 'a
4127 {
4128 let route_str = route.into();
4129 let request = self.base.request(Method::GET, route_str, &format!("/val/match/console/v1/matchlists/by-puuid/{}", puuid));
4130 let request = request.query(&[ ("platformType", platform_type) ]);
4131 let future = self.base.execute_val::<crate::models::val_console_match_v1::Matchlist>("val-console-match-v1.getMatchlist", route_str, request);
4132 #[cfg(feature = "tracing")]
4133 let future = future.instrument(tracing::info_span!("val-console-match-v1.getMatchlist", route = route_str));
4134 #[cfg(feature = "metrics")]
4135 let future = metrics::timed(future, "val-console-match-v1.getMatchlist", route_str);
4136 future
4137 }
4138
4139 pub fn try_get_matchlist(&self, min_capacity: f32, route: ValPlatformRoute, puuid: &str, platform_type: &str)
4151 -> impl Future<Output = TryRequestResult<crate::models::val_console_match_v1::Matchlist>> + 'a
4152 {
4153 let route_str = route.into();
4154 let request = self.base.request(Method::GET, route_str, &format!("/val/match/console/v1/matchlists/by-puuid/{}", puuid));
4155 let request = request.query(&[ ("platformType", platform_type) ]);
4156 let future = self.base.try_execute_val::<crate::models::val_console_match_v1::Matchlist>("val-console-match-v1.getMatchlist", route_str, request, min_capacity);
4157 #[cfg(feature = "tracing")]
4158 let future = future.instrument(tracing::info_span!("val-console-match-v1.getMatchlist", route = route_str));
4159 #[cfg(feature = "metrics")]
4160 let future = metrics::try_timed(future, "val-console-match-v1.getMatchlist", route_str);
4161 future
4162 }
4163
4164 pub fn get_recent(&self, route: ValPlatformRoute, queue: &str)
4175 -> impl Future<Output = Result<crate::models::val_console_match_v1::RecentMatches>> + 'a
4176 {
4177 let route_str = route.into();
4178 let request = self.base.request(Method::GET, route_str, &format!("/val/match/console/v1/recent-matches/by-queue/{}", queue));
4179 let future = self.base.execute_val::<crate::models::val_console_match_v1::RecentMatches>("val-console-match-v1.getRecent", route_str, request);
4180 #[cfg(feature = "tracing")]
4181 let future = future.instrument(tracing::info_span!("val-console-match-v1.getRecent", route = route_str));
4182 #[cfg(feature = "metrics")]
4183 let future = metrics::timed(future, "val-console-match-v1.getRecent", route_str);
4184 future
4185 }
4186
4187 pub fn try_get_recent(&self, min_capacity: f32, route: ValPlatformRoute, queue: &str)
4198 -> impl Future<Output = TryRequestResult<crate::models::val_console_match_v1::RecentMatches>> + 'a
4199 {
4200 let route_str = route.into();
4201 let request = self.base.request(Method::GET, route_str, &format!("/val/match/console/v1/recent-matches/by-queue/{}", queue));
4202 let future = self.base.try_execute_val::<crate::models::val_console_match_v1::RecentMatches>("val-console-match-v1.getRecent", route_str, request, min_capacity);
4203 #[cfg(feature = "tracing")]
4204 let future = future.instrument(tracing::info_span!("val-console-match-v1.getRecent", route = route_str));
4205 #[cfg(feature = "metrics")]
4206 let future = metrics::try_timed(future, "val-console-match-v1.getRecent", route_str);
4207 future
4208 }
4209
4210}
4211
4212#[repr(transparent)]
4218pub struct ValConsoleRankedV1<'a> {
4219 base: &'a RiotApi,
4220}
4221impl<'a> ValConsoleRankedV1<'a> {
4222 pub fn get_leaderboard(&self, route: ValPlatformRoute, act_id: &str, platform_type: &str, size: Option<i32>, start_index: Option<i32>)
4234 -> impl Future<Output = Result<Option<crate::models::val_console_ranked_v1::Leaderboard>>> + 'a
4235 {
4236 let route_str = route.into();
4237 let request = self.base.request(Method::GET, route_str, &format!("/val/console/ranked/v1/leaderboards/by-act/{}", act_id));
4238 let request = request.query(&[ ("platformType", platform_type) ]);
4239 let request = if let Some(size) = size { request.query(&[ ("size", size) ]) } else { request };
4240 let request = if let Some(start_index) = start_index { request.query(&[ ("startIndex", start_index) ]) } else { request };
4241 let future = self.base.execute_opt::<crate::models::val_console_ranked_v1::Leaderboard>("val-console-ranked-v1.getLeaderboard", route_str, request);
4242 #[cfg(feature = "tracing")]
4243 let future = future.instrument(tracing::info_span!("val-console-ranked-v1.getLeaderboard", route = route_str));
4244 #[cfg(feature = "metrics")]
4245 let future = metrics::timed(future, "val-console-ranked-v1.getLeaderboard", route_str);
4246 future
4247 }
4248
4249 pub fn try_get_leaderboard(&self, min_capacity: f32, route: ValPlatformRoute, act_id: &str, platform_type: &str, size: Option<i32>, start_index: Option<i32>)
4263 -> impl Future<Output = TryRequestResult<Option<crate::models::val_console_ranked_v1::Leaderboard>>> + 'a
4264 {
4265 let route_str = route.into();
4266 let request = self.base.request(Method::GET, route_str, &format!("/val/console/ranked/v1/leaderboards/by-act/{}", act_id));
4267 let request = request.query(&[ ("platformType", platform_type) ]);
4268 let request = if let Some(size) = size { request.query(&[ ("size", size) ]) } else { request };
4269 let request = if let Some(start_index) = start_index { request.query(&[ ("startIndex", start_index) ]) } else { request };
4270 let future = self.base.try_execute_opt::<crate::models::val_console_ranked_v1::Leaderboard>("val-console-ranked-v1.getLeaderboard", route_str, request, min_capacity);
4271 #[cfg(feature = "tracing")]
4272 let future = future.instrument(tracing::info_span!("val-console-ranked-v1.getLeaderboard", route = route_str));
4273 #[cfg(feature = "metrics")]
4274 let future = metrics::try_timed(future, "val-console-ranked-v1.getLeaderboard", route_str);
4275 future
4276 }
4277
4278}
4279
4280#[repr(transparent)]
4286pub struct ValContentV1<'a> {
4287 base: &'a RiotApi,
4288}
4289impl<'a> ValContentV1<'a> {
4290 pub fn get_content(&self, route: ValPlatformRoute, locale: Option<&str>)
4299 -> impl Future<Output = Result<crate::models::val_content_v1::Content>> + 'a
4300 {
4301 let route_str = route.into();
4302 let request = self.base.request(Method::GET, route_str, "/val/content/v1/contents");
4303 let request = if let Some(locale) = locale { request.query(&[ ("locale", locale) ]) } else { request };
4304 let future = self.base.execute_val::<crate::models::val_content_v1::Content>("val-content-v1.getContent", route_str, request);
4305 #[cfg(feature = "tracing")]
4306 let future = future.instrument(tracing::info_span!("val-content-v1.getContent", route = route_str));
4307 #[cfg(feature = "metrics")]
4308 let future = metrics::timed(future, "val-content-v1.getContent", route_str);
4309 future
4310 }
4311
4312 pub fn try_get_content(&self, min_capacity: f32, route: ValPlatformRoute, locale: Option<&str>)
4323 -> impl Future<Output = TryRequestResult<crate::models::val_content_v1::Content>> + 'a
4324 {
4325 let route_str = route.into();
4326 let request = self.base.request(Method::GET, route_str, "/val/content/v1/contents");
4327 let request = if let Some(locale) = locale { request.query(&[ ("locale", locale) ]) } else { request };
4328 let future = self.base.try_execute_val::<crate::models::val_content_v1::Content>("val-content-v1.getContent", route_str, request, min_capacity);
4329 #[cfg(feature = "tracing")]
4330 let future = future.instrument(tracing::info_span!("val-content-v1.getContent", route = route_str));
4331 #[cfg(feature = "metrics")]
4332 let future = metrics::try_timed(future, "val-content-v1.getContent", route_str);
4333 future
4334 }
4335
4336}
4337
4338#[repr(transparent)]
4344pub struct ValMatchV1<'a> {
4345 base: &'a RiotApi,
4346}
4347impl<'a> ValMatchV1<'a> {
4348 pub fn get_match(&self, route: ValPlatformRoute, match_id: &str)
4357 -> impl Future<Output = Result<Option<crate::models::val_match_v1::Match>>> + 'a
4358 {
4359 let route_str = route.into();
4360 let request = self.base.request(Method::GET, route_str, &format!("/val/match/v1/matches/{}", match_id));
4361 let future = self.base.execute_opt::<crate::models::val_match_v1::Match>("val-match-v1.getMatch", route_str, request);
4362 #[cfg(feature = "tracing")]
4363 let future = future.instrument(tracing::info_span!("val-match-v1.getMatch", route = route_str));
4364 #[cfg(feature = "metrics")]
4365 let future = metrics::timed(future, "val-match-v1.getMatch", route_str);
4366 future
4367 }
4368
4369 pub fn try_get_match(&self, min_capacity: f32, route: ValPlatformRoute, match_id: &str)
4380 -> impl Future<Output = TryRequestResult<Option<crate::models::val_match_v1::Match>>> + 'a
4381 {
4382 let route_str = route.into();
4383 let request = self.base.request(Method::GET, route_str, &format!("/val/match/v1/matches/{}", match_id));
4384 let future = self.base.try_execute_opt::<crate::models::val_match_v1::Match>("val-match-v1.getMatch", route_str, request, min_capacity);
4385 #[cfg(feature = "tracing")]
4386 let future = future.instrument(tracing::info_span!("val-match-v1.getMatch", route = route_str));
4387 #[cfg(feature = "metrics")]
4388 let future = metrics::try_timed(future, "val-match-v1.getMatch", route_str);
4389 future
4390 }
4391
4392 pub fn get_matchlist(&self, route: ValPlatformRoute, puuid: &str)
4401 -> impl Future<Output = Result<crate::models::val_match_v1::Matchlist>> + 'a
4402 {
4403 let route_str = route.into();
4404 let request = self.base.request(Method::GET, route_str, &format!("/val/match/v1/matchlists/by-puuid/{}", puuid));
4405 let future = self.base.execute_val::<crate::models::val_match_v1::Matchlist>("val-match-v1.getMatchlist", route_str, request);
4406 #[cfg(feature = "tracing")]
4407 let future = future.instrument(tracing::info_span!("val-match-v1.getMatchlist", route = route_str));
4408 #[cfg(feature = "metrics")]
4409 let future = metrics::timed(future, "val-match-v1.getMatchlist", route_str);
4410 future
4411 }
4412
4413 pub fn try_get_matchlist(&self, min_capacity: f32, route: ValPlatformRoute, puuid: &str)
4424 -> impl Future<Output = TryRequestResult<crate::models::val_match_v1::Matchlist>> + 'a
4425 {
4426 let route_str = route.into();
4427 let request = self.base.request(Method::GET, route_str, &format!("/val/match/v1/matchlists/by-puuid/{}", puuid));
4428 let future = self.base.try_execute_val::<crate::models::val_match_v1::Matchlist>("val-match-v1.getMatchlist", route_str, request, min_capacity);
4429 #[cfg(feature = "tracing")]
4430 let future = future.instrument(tracing::info_span!("val-match-v1.getMatchlist", route = route_str));
4431 #[cfg(feature = "metrics")]
4432 let future = metrics::try_timed(future, "val-match-v1.getMatchlist", route_str);
4433 future
4434 }
4435
4436 pub fn get_recent(&self, route: ValPlatformRoute, queue: &str)
4447 -> impl Future<Output = Result<crate::models::val_match_v1::RecentMatches>> + 'a
4448 {
4449 let route_str = route.into();
4450 let request = self.base.request(Method::GET, route_str, &format!("/val/match/v1/recent-matches/by-queue/{}", queue));
4451 let future = self.base.execute_val::<crate::models::val_match_v1::RecentMatches>("val-match-v1.getRecent", route_str, request);
4452 #[cfg(feature = "tracing")]
4453 let future = future.instrument(tracing::info_span!("val-match-v1.getRecent", route = route_str));
4454 #[cfg(feature = "metrics")]
4455 let future = metrics::timed(future, "val-match-v1.getRecent", route_str);
4456 future
4457 }
4458
4459 pub fn try_get_recent(&self, min_capacity: f32, route: ValPlatformRoute, queue: &str)
4470 -> impl Future<Output = TryRequestResult<crate::models::val_match_v1::RecentMatches>> + 'a
4471 {
4472 let route_str = route.into();
4473 let request = self.base.request(Method::GET, route_str, &format!("/val/match/v1/recent-matches/by-queue/{}", queue));
4474 let future = self.base.try_execute_val::<crate::models::val_match_v1::RecentMatches>("val-match-v1.getRecent", route_str, request, min_capacity);
4475 #[cfg(feature = "tracing")]
4476 let future = future.instrument(tracing::info_span!("val-match-v1.getRecent", route = route_str));
4477 #[cfg(feature = "metrics")]
4478 let future = metrics::try_timed(future, "val-match-v1.getRecent", route_str);
4479 future
4480 }
4481
4482}
4483
4484#[repr(transparent)]
4490pub struct ValRankedV1<'a> {
4491 base: &'a RiotApi,
4492}
4493impl<'a> ValRankedV1<'a> {
4494 pub fn get_leaderboard(&self, route: ValPlatformRoute, act_id: &str, size: Option<i32>, start_index: Option<i32>)
4505 -> impl Future<Output = Result<Option<crate::models::val_ranked_v1::Leaderboard>>> + 'a
4506 {
4507 let route_str = route.into();
4508 let request = self.base.request(Method::GET, route_str, &format!("/val/ranked/v1/leaderboards/by-act/{}", act_id));
4509 let request = if let Some(size) = size { request.query(&[ ("size", size) ]) } else { request };
4510 let request = if let Some(start_index) = start_index { request.query(&[ ("startIndex", start_index) ]) } else { request };
4511 let future = self.base.execute_opt::<crate::models::val_ranked_v1::Leaderboard>("val-ranked-v1.getLeaderboard", route_str, request);
4512 #[cfg(feature = "tracing")]
4513 let future = future.instrument(tracing::info_span!("val-ranked-v1.getLeaderboard", route = route_str));
4514 #[cfg(feature = "metrics")]
4515 let future = metrics::timed(future, "val-ranked-v1.getLeaderboard", route_str);
4516 future
4517 }
4518
4519 pub fn try_get_leaderboard(&self, min_capacity: f32, route: ValPlatformRoute, act_id: &str, size: Option<i32>, start_index: Option<i32>)
4532 -> impl Future<Output = TryRequestResult<Option<crate::models::val_ranked_v1::Leaderboard>>> + 'a
4533 {
4534 let route_str = route.into();
4535 let request = self.base.request(Method::GET, route_str, &format!("/val/ranked/v1/leaderboards/by-act/{}", act_id));
4536 let request = if let Some(size) = size { request.query(&[ ("size", size) ]) } else { request };
4537 let request = if let Some(start_index) = start_index { request.query(&[ ("startIndex", start_index) ]) } else { request };
4538 let future = self.base.try_execute_opt::<crate::models::val_ranked_v1::Leaderboard>("val-ranked-v1.getLeaderboard", route_str, request, min_capacity);
4539 #[cfg(feature = "tracing")]
4540 let future = future.instrument(tracing::info_span!("val-ranked-v1.getLeaderboard", route = route_str));
4541 #[cfg(feature = "metrics")]
4542 let future = metrics::try_timed(future, "val-ranked-v1.getLeaderboard", route_str);
4543 future
4544 }
4545
4546}
4547
4548#[repr(transparent)]
4554pub struct ValStatusV1<'a> {
4555 base: &'a RiotApi,
4556}
4557impl<'a> ValStatusV1<'a> {
4558 pub fn get_platform_data(&self, route: ValPlatformRoute)
4566 -> impl Future<Output = Result<crate::models::val_status_v1::PlatformData>> + 'a
4567 {
4568 let route_str = route.into();
4569 let request = self.base.request(Method::GET, route_str, "/val/status/v1/platform-data");
4570 let future = self.base.execute_val::<crate::models::val_status_v1::PlatformData>("val-status-v1.getPlatformData", route_str, request);
4571 #[cfg(feature = "tracing")]
4572 let future = future.instrument(tracing::info_span!("val-status-v1.getPlatformData", route = route_str));
4573 #[cfg(feature = "metrics")]
4574 let future = metrics::timed(future, "val-status-v1.getPlatformData", route_str);
4575 future
4576 }
4577
4578 pub fn try_get_platform_data(&self, min_capacity: f32, route: ValPlatformRoute)
4588 -> impl Future<Output = TryRequestResult<crate::models::val_status_v1::PlatformData>> + 'a
4589 {
4590 let route_str = route.into();
4591 let request = self.base.request(Method::GET, route_str, "/val/status/v1/platform-data");
4592 let future = self.base.try_execute_val::<crate::models::val_status_v1::PlatformData>("val-status-v1.getPlatformData", route_str, request, min_capacity);
4593 #[cfg(feature = "tracing")]
4594 let future = future.instrument(tracing::info_span!("val-status-v1.getPlatformData", route = route_str));
4595 #[cfg(feature = "metrics")]
4596 let future = metrics::try_timed(future, "val-status-v1.getPlatformData", route_str);
4597 future
4598 }
4599
4600}