Struct Client 

pub struct Client { /* private fields */ }

Client for interacting with the FACEIT Public API

Implementations

impl Client

pub fn new() -> Self

Create a new client without authentication

Requests without authentication are subject to standard rate limits.

Examples

use faceit::HttpClient;

let client = HttpClient::new();

Examples found in repository

examples/ergonomic_api.rs (line 5)

async fn main() -> Result<(), faceit::error::Error> {
    let client = HttpClient::new();

    // Example 1: Player API
    println!("=== Player API ===");
    let player = faceit::http::ergonomic::Player::new("player-id-here", &client);

    // Get player details
    match player.get().await {
        Ok(player_data) => {
            println!("Player: {}", player_data.nickname);
            if let Some(country) = player_data.country {
                println!("Country: {}", country);
            }
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Get player stats
    match player.stats("cs2").await {
        Ok(stats) => {
            println!("Stats retrieved for game: {}", stats.game_id);
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Get player match history
    match player.history("cs2", None, None, Some(0), Some(20)).await {
        Ok(history) => {
            println!("Found {} matches", history.items.len());
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Get player hubs
    match player.hubs(Some(0), Some(50)).await {
        Ok(hubs) => {
            println!("Found {} hubs", hubs.items.len());
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Example 2: Match API
    println!("\n=== Match API ===");
    let match_obj = faceit::http::ergonomic::Match::new("match-id-here", &client);

    match match_obj.get().await {
        Ok(match_data) => {
            println!("Match ID: {}", match_data.match_id);
            println!("Status: {}", match_data.status);
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    match match_obj.stats().await {
        Ok(stats) => {
            println!("Rounds: {}", stats.rounds.len());
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Example 3: Game API
    println!("\n=== Game API ===");
    let game = faceit::http::ergonomic::Game::new("cs2", &client);

    match game.get().await {
        Ok(game_data) => {
            println!("Game: {}", game_data.long_label);
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    match game.matchmakings(Some("EU"), Some(0), Some(20)).await {
        Ok(matchmakings) => {
            println!("Found {} matchmakings", matchmakings.items.len());
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Example 4: Hub API
    println!("\n=== Hub API ===");
    let hub = faceit::http::ergonomic::Hub::new("hub-id-here", &client);

    match hub.get(None).await {
        Ok(hub_data) => {
            println!("Hub: {}", hub_data.name);
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    match hub.matches(Some("all"), Some(0), Some(20)).await {
        Ok(matches) => {
            println!("Found {} matches", matches.items.len());
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    match hub.members(Some(0), Some(50)).await {
        Ok(members) => {
            println!("Found {} members", members.items.len());
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Example 5: Championship API
    println!("\n=== Championship API ===");
    let championship = faceit::http::ergonomic::Championship::new("championship-id-here", &client);

    match championship.get(None).await {
        Ok(championship_data) => {
            println!("Championship: {}", championship_data.name);
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    match championship.matches(Some("all"), Some(0), Some(20)).await {
        Ok(matches) => {
            println!("Found {} matches", matches.items.len());
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Example 6: Direct instantiation (alternative to client methods)
    println!("\n=== Direct Instantiation ===");
    use faceit::http::ergonomic::{Championship, Game, Hub, Match, Player};

    let _player2 = Player::new("player-id-here", &client);
    let _match_obj2 = Match::new("match-id-here", &client);
    let _game2 = Game::new("cs2", &client);
    let _hub2 = Hub::new("hub-id-here", &client);
    let _championship2 = Championship::new("championship-id-here", &client);

    println!("Created ergonomic API instances directly");

    Ok(())
}

examples/basic_usage.rs (line 6)

async fn main() -> Result<(), faceit::error::Error> {
    // Create a client (without authentication)
    let client = HttpClient::new();

    // Or create a client with API key or access token:
    // let client = Client::builder()
    //     .api_key("your-api-key-or-access-token")
    //     .build()?;

    // Example 1: Get player by ID
    println!("Fetching player by ID...");
    match client.get_player("player-id-here").await {
        Ok(player) => {
            println!("Player: {}", player.nickname);
            if let Some(country) = player.country {
                println!("Country: {}", country);
            }
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 2: Get player from lookup by nickname
    println!("\nFetching player from lookup...");
    match client
        .get_player_from_lookup(Some("player_nickname"), Some("cs2"), None)
        .await
    {
        Ok(player) => {
            println!("Player: {}", player.nickname);
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 3: Get player stats
    println!("\nFetching player stats...");
    match client.get_player_stats("player-id-here", "cs2").await {
        Ok(stats) => {
            println!("Player ID: {}", stats.player_id);
            println!("Game ID: {}", stats.game_id);
        }
        Err(e) => eprintln!("Error fetching stats: {}", e),
    }

    // Example 4: Get player match history
    println!("\nFetching player match history...");
    match client
        .get_player_history("player-id-here", "cs2", None, None, Some(0), Some(20))
        .await
    {
        Ok(history) => {
            println!("Found {} matches", history.items.len());
            if let Some(first_match) = history.items.first() {
                println!("Most recent match: {}", first_match.match_id);
            }
        }
        Err(e) => eprintln!("Error fetching history: {}", e),
    }

    // Example 5: Get match details
    println!("\nFetching match details...");
    match client.get_match("match-id-here").await {
        Ok(match_details) => {
            println!("Match ID: {}", match_details.match_id);
            println!("Game: {}", match_details.game);
            println!("Status: {}", match_details.status);
        }
        Err(e) => eprintln!("Error fetching match: {}", e),
    }

    // Example 6: Get match stats
    println!("\nFetching match stats...");
    match client.get_match_stats("match-id-here").await {
        Ok(stats) => {
            println!("Rounds: {}", stats.rounds.len());
        }
        Err(e) => eprintln!("Error fetching match stats: {}", e),
    }

    // Example 7: Search for players
    println!("\nSearching for players...");
    match client
        .search_players("player_name", Some("cs2"), None, Some(0), Some(20))
        .await
    {
        Ok(results) => {
            println!("Found {} players", results.items.len());
            for player in results.items.iter().take(5) {
                println!("  - {} ({})", player.nickname, player.player_id);
            }
        }
        Err(e) => eprintln!("Error searching players: {}", e),
    }

    // Example 8: Get all games
    println!("\nFetching all games...");
    match client.get_all_games(Some(0), Some(20)).await {
        Ok(games) => {
            println!("Found {} games", games.items.len());
            for game in games.items.iter().take(5) {
                println!("  - {} ({})", game.long_label, game.game_id);
            }
        }
        Err(e) => eprintln!("Error fetching games: {}", e),
    }

    // Example 9: Get hub details
    println!("\nFetching hub details...");
    match client.get_hub("hub-id-here", None).await {
        Ok(hub) => {
            println!("Hub: {}", hub.name);
            println!("Game: {}", hub.game_id);
        }
        Err(e) => eprintln!("Error fetching hub: {}", e),
    }

    // Example 10: Get global ranking
    println!("\nFetching global ranking...");
    match client
        .get_global_ranking("cs2", "EU", None, Some(0), Some(20))
        .await
    {
        Ok(ranking) => {
            println!("Found {} players in ranking", ranking.items.len());
            for entry in ranking.items.iter().take(5) {
                println!(
                    "  {}: {} - ELO: {}",
                    entry.position, entry.nickname, entry.faceit_elo
                );
            }
        }
        Err(e) => eprintln!("Error fetching ranking: {}", e),
    }

    // Example 11: Using the builder pattern with authentication
    println!("\nCreating client with builder...");
    let _custom_client = HttpClient::builder()
        .api_key("your-api-key-or-access-token-here")
        .timeout(std::time::Duration::from_secs(60))
        .build()?;

    println!("Client created with custom configuration");

    Ok(())
}

pub fn builder() -> ClientBuilder

Create a builder for customizing the client configuration

Examples

use faceit::HttpClient;
use std::time::Duration;

let client = HttpClient::builder()
    .api_key("your-api-key-or-access-token")
    .timeout(Duration::from_secs(60))
    .base_url("https://custom-api.example.com")
    .build()
    .unwrap();

Examples found in repository

examples/basic_usage.rs (line 139)

async fn main() -> Result<(), faceit::error::Error> {
    // Create a client (without authentication)
    let client = HttpClient::new();

    // Or create a client with API key or access token:
    // let client = Client::builder()
    //     .api_key("your-api-key-or-access-token")
    //     .build()?;

    // Example 1: Get player by ID
    println!("Fetching player by ID...");
    match client.get_player("player-id-here").await {
        Ok(player) => {
            println!("Player: {}", player.nickname);
            if let Some(country) = player.country {
                println!("Country: {}", country);
            }
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 2: Get player from lookup by nickname
    println!("\nFetching player from lookup...");
    match client
        .get_player_from_lookup(Some("player_nickname"), Some("cs2"), None)
        .await
    {
        Ok(player) => {
            println!("Player: {}", player.nickname);
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 3: Get player stats
    println!("\nFetching player stats...");
    match client.get_player_stats("player-id-here", "cs2").await {
        Ok(stats) => {
            println!("Player ID: {}", stats.player_id);
            println!("Game ID: {}", stats.game_id);
        }
        Err(e) => eprintln!("Error fetching stats: {}", e),
    }

    // Example 4: Get player match history
    println!("\nFetching player match history...");
    match client
        .get_player_history("player-id-here", "cs2", None, None, Some(0), Some(20))
        .await
    {
        Ok(history) => {
            println!("Found {} matches", history.items.len());
            if let Some(first_match) = history.items.first() {
                println!("Most recent match: {}", first_match.match_id);
            }
        }
        Err(e) => eprintln!("Error fetching history: {}", e),
    }

    // Example 5: Get match details
    println!("\nFetching match details...");
    match client.get_match("match-id-here").await {
        Ok(match_details) => {
            println!("Match ID: {}", match_details.match_id);
            println!("Game: {}", match_details.game);
            println!("Status: {}", match_details.status);
        }
        Err(e) => eprintln!("Error fetching match: {}", e),
    }

    // Example 6: Get match stats
    println!("\nFetching match stats...");
    match client.get_match_stats("match-id-here").await {
        Ok(stats) => {
            println!("Rounds: {}", stats.rounds.len());
        }
        Err(e) => eprintln!("Error fetching match stats: {}", e),
    }

    // Example 7: Search for players
    println!("\nSearching for players...");
    match client
        .search_players("player_name", Some("cs2"), None, Some(0), Some(20))
        .await
    {
        Ok(results) => {
            println!("Found {} players", results.items.len());
            for player in results.items.iter().take(5) {
                println!("  - {} ({})", player.nickname, player.player_id);
            }
        }
        Err(e) => eprintln!("Error searching players: {}", e),
    }

    // Example 8: Get all games
    println!("\nFetching all games...");
    match client.get_all_games(Some(0), Some(20)).await {
        Ok(games) => {
            println!("Found {} games", games.items.len());
            for game in games.items.iter().take(5) {
                println!("  - {} ({})", game.long_label, game.game_id);
            }
        }
        Err(e) => eprintln!("Error fetching games: {}", e),
    }

    // Example 9: Get hub details
    println!("\nFetching hub details...");
    match client.get_hub("hub-id-here", None).await {
        Ok(hub) => {
            println!("Hub: {}", hub.name);
            println!("Game: {}", hub.game_id);
        }
        Err(e) => eprintln!("Error fetching hub: {}", e),
    }

    // Example 10: Get global ranking
    println!("\nFetching global ranking...");
    match client
        .get_global_ranking("cs2", "EU", None, Some(0), Some(20))
        .await
    {
        Ok(ranking) => {
            println!("Found {} players in ranking", ranking.items.len());
            for entry in ranking.items.iter().take(5) {
                println!(
                    "  {}: {} - ELO: {}",
                    entry.position, entry.nickname, entry.faceit_elo
                );
            }
        }
        Err(e) => eprintln!("Error fetching ranking: {}", e),
    }

    // Example 11: Using the builder pattern with authentication
    println!("\nCreating client with builder...");
    let _custom_client = HttpClient::builder()
        .api_key("your-api-key-or-access-token-here")
        .timeout(std::time::Duration::from_secs(60))
        .build()?;

    println!("Client created with custom configuration");

    Ok(())
}

pub async fn get_player(&self, player_id: &str) -> Result<Player, Error>

Get player details by player ID

Arguments

• player_id - The FACEIT player ID (UUID format)

Examples

let client = HttpClient::new();
let player = client.get_player("player-id-here").await?;
println!("Player: {}", player.nickname);

Examples found in repository

examples/basic_usage.rs (line 15)

async fn main() -> Result<(), faceit::error::Error> {
    // Create a client (without authentication)
    let client = HttpClient::new();

    // Or create a client with API key or access token:
    // let client = Client::builder()
    //     .api_key("your-api-key-or-access-token")
    //     .build()?;

    // Example 1: Get player by ID
    println!("Fetching player by ID...");
    match client.get_player("player-id-here").await {
        Ok(player) => {
            println!("Player: {}", player.nickname);
            if let Some(country) = player.country {
                println!("Country: {}", country);
            }
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 2: Get player from lookup by nickname
    println!("\nFetching player from lookup...");
    match client
        .get_player_from_lookup(Some("player_nickname"), Some("cs2"), None)
        .await
    {
        Ok(player) => {
            println!("Player: {}", player.nickname);
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 3: Get player stats
    println!("\nFetching player stats...");
    match client.get_player_stats("player-id-here", "cs2").await {
        Ok(stats) => {
            println!("Player ID: {}", stats.player_id);
            println!("Game ID: {}", stats.game_id);
        }
        Err(e) => eprintln!("Error fetching stats: {}", e),
    }

    // Example 4: Get player match history
    println!("\nFetching player match history...");
    match client
        .get_player_history("player-id-here", "cs2", None, None, Some(0), Some(20))
        .await
    {
        Ok(history) => {
            println!("Found {} matches", history.items.len());
            if let Some(first_match) = history.items.first() {
                println!("Most recent match: {}", first_match.match_id);
            }
        }
        Err(e) => eprintln!("Error fetching history: {}", e),
    }

    // Example 5: Get match details
    println!("\nFetching match details...");
    match client.get_match("match-id-here").await {
        Ok(match_details) => {
            println!("Match ID: {}", match_details.match_id);
            println!("Game: {}", match_details.game);
            println!("Status: {}", match_details.status);
        }
        Err(e) => eprintln!("Error fetching match: {}", e),
    }

    // Example 6: Get match stats
    println!("\nFetching match stats...");
    match client.get_match_stats("match-id-here").await {
        Ok(stats) => {
            println!("Rounds: {}", stats.rounds.len());
        }
        Err(e) => eprintln!("Error fetching match stats: {}", e),
    }

    // Example 7: Search for players
    println!("\nSearching for players...");
    match client
        .search_players("player_name", Some("cs2"), None, Some(0), Some(20))
        .await
    {
        Ok(results) => {
            println!("Found {} players", results.items.len());
            for player in results.items.iter().take(5) {
                println!("  - {} ({})", player.nickname, player.player_id);
            }
        }
        Err(e) => eprintln!("Error searching players: {}", e),
    }

    // Example 8: Get all games
    println!("\nFetching all games...");
    match client.get_all_games(Some(0), Some(20)).await {
        Ok(games) => {
            println!("Found {} games", games.items.len());
            for game in games.items.iter().take(5) {
                println!("  - {} ({})", game.long_label, game.game_id);
            }
        }
        Err(e) => eprintln!("Error fetching games: {}", e),
    }

    // Example 9: Get hub details
    println!("\nFetching hub details...");
    match client.get_hub("hub-id-here", None).await {
        Ok(hub) => {
            println!("Hub: {}", hub.name);
            println!("Game: {}", hub.game_id);
        }
        Err(e) => eprintln!("Error fetching hub: {}", e),
    }

    // Example 10: Get global ranking
    println!("\nFetching global ranking...");
    match client
        .get_global_ranking("cs2", "EU", None, Some(0), Some(20))
        .await
    {
        Ok(ranking) => {
            println!("Found {} players in ranking", ranking.items.len());
            for entry in ranking.items.iter().take(5) {
                println!(
                    "  {}: {} - ELO: {}",
                    entry.position, entry.nickname, entry.faceit_elo
                );
            }
        }
        Err(e) => eprintln!("Error fetching ranking: {}", e),
    }

    // Example 11: Using the builder pattern with authentication
    println!("\nCreating client with builder...");
    let _custom_client = HttpClient::builder()
        .api_key("your-api-key-or-access-token-here")
        .timeout(std::time::Duration::from_secs(60))
        .build()?;

    println!("Client created with custom configuration");

    Ok(())
}

pub async fn get_player_from_lookup( &self, nickname: Option<&str>, game: Option<&str>, game_player_id: Option<&str>, ) -> Result<Player, Error>

Get player details from lookup (by nickname, game, or game_player_id)

Arguments

• nickname - Optional player nickname
• game - Optional game ID
• game_player_id - Optional game-specific player ID

Examples

let client = HttpClient::new();
let player = client.get_player_from_lookup(Some("player_nickname"), None, None).await?;

Examples found in repository

examples/basic_usage.rs (line 28)

async fn main() -> Result<(), faceit::error::Error> {
    // Create a client (without authentication)
    let client = HttpClient::new();

    // Or create a client with API key or access token:
    // let client = Client::builder()
    //     .api_key("your-api-key-or-access-token")
    //     .build()?;

    // Example 1: Get player by ID
    println!("Fetching player by ID...");
    match client.get_player("player-id-here").await {
        Ok(player) => {
            println!("Player: {}", player.nickname);
            if let Some(country) = player.country {
                println!("Country: {}", country);
            }
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 2: Get player from lookup by nickname
    println!("\nFetching player from lookup...");
    match client
        .get_player_from_lookup(Some("player_nickname"), Some("cs2"), None)
        .await
    {
        Ok(player) => {
            println!("Player: {}", player.nickname);
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 3: Get player stats
    println!("\nFetching player stats...");
    match client.get_player_stats("player-id-here", "cs2").await {
        Ok(stats) => {
            println!("Player ID: {}", stats.player_id);
            println!("Game ID: {}", stats.game_id);
        }
        Err(e) => eprintln!("Error fetching stats: {}", e),
    }

    // Example 4: Get player match history
    println!("\nFetching player match history...");
    match client
        .get_player_history("player-id-here", "cs2", None, None, Some(0), Some(20))
        .await
    {
        Ok(history) => {
            println!("Found {} matches", history.items.len());
            if let Some(first_match) = history.items.first() {
                println!("Most recent match: {}", first_match.match_id);
            }
        }
        Err(e) => eprintln!("Error fetching history: {}", e),
    }

    // Example 5: Get match details
    println!("\nFetching match details...");
    match client.get_match("match-id-here").await {
        Ok(match_details) => {
            println!("Match ID: {}", match_details.match_id);
            println!("Game: {}", match_details.game);
            println!("Status: {}", match_details.status);
        }
        Err(e) => eprintln!("Error fetching match: {}", e),
    }

    // Example 6: Get match stats
    println!("\nFetching match stats...");
    match client.get_match_stats("match-id-here").await {
        Ok(stats) => {
            println!("Rounds: {}", stats.rounds.len());
        }
        Err(e) => eprintln!("Error fetching match stats: {}", e),
    }

    // Example 7: Search for players
    println!("\nSearching for players...");
    match client
        .search_players("player_name", Some("cs2"), None, Some(0), Some(20))
        .await
    {
        Ok(results) => {
            println!("Found {} players", results.items.len());
            for player in results.items.iter().take(5) {
                println!("  - {} ({})", player.nickname, player.player_id);
            }
        }
        Err(e) => eprintln!("Error searching players: {}", e),
    }

    // Example 8: Get all games
    println!("\nFetching all games...");
    match client.get_all_games(Some(0), Some(20)).await {
        Ok(games) => {
            println!("Found {} games", games.items.len());
            for game in games.items.iter().take(5) {
                println!("  - {} ({})", game.long_label, game.game_id);
            }
        }
        Err(e) => eprintln!("Error fetching games: {}", e),
    }

    // Example 9: Get hub details
    println!("\nFetching hub details...");
    match client.get_hub("hub-id-here", None).await {
        Ok(hub) => {
            println!("Hub: {}", hub.name);
            println!("Game: {}", hub.game_id);
        }
        Err(e) => eprintln!("Error fetching hub: {}", e),
    }

    // Example 10: Get global ranking
    println!("\nFetching global ranking...");
    match client
        .get_global_ranking("cs2", "EU", None, Some(0), Some(20))
        .await
    {
        Ok(ranking) => {
            println!("Found {} players in ranking", ranking.items.len());
            for entry in ranking.items.iter().take(5) {
                println!(
                    "  {}: {} - ELO: {}",
                    entry.position, entry.nickname, entry.faceit_elo
                );
            }
        }
        Err(e) => eprintln!("Error fetching ranking: {}", e),
    }

    // Example 11: Using the builder pattern with authentication
    println!("\nCreating client with builder...");
    let _custom_client = HttpClient::builder()
        .api_key("your-api-key-or-access-token-here")
        .timeout(std::time::Duration::from_secs(60))
        .build()?;

    println!("Client created with custom configuration");

    Ok(())
}

pub async fn get_player_stats( &self, player_id: &str, game_id: &str, ) -> Result<PlayerStats, Error>

Get player statistics for a specific game

Arguments

• player_id - The FACEIT player ID
• game_id - The game ID (e.g., “cs2”, “csgo”)

Examples

let client = HttpClient::new();
let stats = client.get_player_stats("player-id", "cs2").await?;

Examples found in repository

examples/basic_usage.rs (line 39)

async fn main() -> Result<(), faceit::error::Error> {
    // Create a client (without authentication)
    let client = HttpClient::new();

    // Or create a client with API key or access token:
    // let client = Client::builder()
    //     .api_key("your-api-key-or-access-token")
    //     .build()?;

    // Example 1: Get player by ID
    println!("Fetching player by ID...");
    match client.get_player("player-id-here").await {
        Ok(player) => {
            println!("Player: {}", player.nickname);
            if let Some(country) = player.country {
                println!("Country: {}", country);
            }
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 2: Get player from lookup by nickname
    println!("\nFetching player from lookup...");
    match client
        .get_player_from_lookup(Some("player_nickname"), Some("cs2"), None)
        .await
    {
        Ok(player) => {
            println!("Player: {}", player.nickname);
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 3: Get player stats
    println!("\nFetching player stats...");
    match client.get_player_stats("player-id-here", "cs2").await {
        Ok(stats) => {
            println!("Player ID: {}", stats.player_id);
            println!("Game ID: {}", stats.game_id);
        }
        Err(e) => eprintln!("Error fetching stats: {}", e),
    }

    // Example 4: Get player match history
    println!("\nFetching player match history...");
    match client
        .get_player_history("player-id-here", "cs2", None, None, Some(0), Some(20))
        .await
    {
        Ok(history) => {
            println!("Found {} matches", history.items.len());
            if let Some(first_match) = history.items.first() {
                println!("Most recent match: {}", first_match.match_id);
            }
        }
        Err(e) => eprintln!("Error fetching history: {}", e),
    }

    // Example 5: Get match details
    println!("\nFetching match details...");
    match client.get_match("match-id-here").await {
        Ok(match_details) => {
            println!("Match ID: {}", match_details.match_id);
            println!("Game: {}", match_details.game);
            println!("Status: {}", match_details.status);
        }
        Err(e) => eprintln!("Error fetching match: {}", e),
    }

    // Example 6: Get match stats
    println!("\nFetching match stats...");
    match client.get_match_stats("match-id-here").await {
        Ok(stats) => {
            println!("Rounds: {}", stats.rounds.len());
        }
        Err(e) => eprintln!("Error fetching match stats: {}", e),
    }

    // Example 7: Search for players
    println!("\nSearching for players...");
    match client
        .search_players("player_name", Some("cs2"), None, Some(0), Some(20))
        .await
    {
        Ok(results) => {
            println!("Found {} players", results.items.len());
            for player in results.items.iter().take(5) {
                println!("  - {} ({})", player.nickname, player.player_id);
            }
        }
        Err(e) => eprintln!("Error searching players: {}", e),
    }

    // Example 8: Get all games
    println!("\nFetching all games...");
    match client.get_all_games(Some(0), Some(20)).await {
        Ok(games) => {
            println!("Found {} games", games.items.len());
            for game in games.items.iter().take(5) {
                println!("  - {} ({})", game.long_label, game.game_id);
            }
        }
        Err(e) => eprintln!("Error fetching games: {}", e),
    }

    // Example 9: Get hub details
    println!("\nFetching hub details...");
    match client.get_hub("hub-id-here", None).await {
        Ok(hub) => {
            println!("Hub: {}", hub.name);
            println!("Game: {}", hub.game_id);
        }
        Err(e) => eprintln!("Error fetching hub: {}", e),
    }

    // Example 10: Get global ranking
    println!("\nFetching global ranking...");
    match client
        .get_global_ranking("cs2", "EU", None, Some(0), Some(20))
        .await
    {
        Ok(ranking) => {
            println!("Found {} players in ranking", ranking.items.len());
            for entry in ranking.items.iter().take(5) {
                println!(
                    "  {}: {} - ELO: {}",
                    entry.position, entry.nickname, entry.faceit_elo
                );
            }
        }
        Err(e) => eprintln!("Error fetching ranking: {}", e),
    }

    // Example 11: Using the builder pattern with authentication
    println!("\nCreating client with builder...");
    let _custom_client = HttpClient::builder()
        .api_key("your-api-key-or-access-token-here")
        .timeout(std::time::Duration::from_secs(60))
        .build()?;

    println!("Client created with custom configuration");

    Ok(())
}

pub async fn get_player_history( &self, player_id: &str, game: &str, from: Option<i64>, to: Option<i64>, offset: Option<i64>, limit: Option<i64>, ) -> Result<MatchHistoryList, Error>

Get player match history

Arguments

• player_id - The FACEIT player ID
• game - The game ID (required)
• from - Optional start timestamp (Unix time)
• to - Optional end timestamp (Unix time)
• offset - Optional offset for pagination (default: 0)
• limit - Optional limit for pagination (default: 20, max: 100)

Examples

let client = HttpClient::new();
let history = client.get_player_history("player-id", "cs2", None, None, Some(0), Some(20)).await?;

Examples found in repository

examples/basic_usage.rs (line 50)

async fn main() -> Result<(), faceit::error::Error> {
    // Create a client (without authentication)
    let client = HttpClient::new();

    // Or create a client with API key or access token:
    // let client = Client::builder()
    //     .api_key("your-api-key-or-access-token")
    //     .build()?;

    // Example 1: Get player by ID
    println!("Fetching player by ID...");
    match client.get_player("player-id-here").await {
        Ok(player) => {
            println!("Player: {}", player.nickname);
            if let Some(country) = player.country {
                println!("Country: {}", country);
            }
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 2: Get player from lookup by nickname
    println!("\nFetching player from lookup...");
    match client
        .get_player_from_lookup(Some("player_nickname"), Some("cs2"), None)
        .await
    {
        Ok(player) => {
            println!("Player: {}", player.nickname);
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 3: Get player stats
    println!("\nFetching player stats...");
    match client.get_player_stats("player-id-here", "cs2").await {
        Ok(stats) => {
            println!("Player ID: {}", stats.player_id);
            println!("Game ID: {}", stats.game_id);
        }
        Err(e) => eprintln!("Error fetching stats: {}", e),
    }

    // Example 4: Get player match history
    println!("\nFetching player match history...");
    match client
        .get_player_history("player-id-here", "cs2", None, None, Some(0), Some(20))
        .await
    {
        Ok(history) => {
            println!("Found {} matches", history.items.len());
            if let Some(first_match) = history.items.first() {
                println!("Most recent match: {}", first_match.match_id);
            }
        }
        Err(e) => eprintln!("Error fetching history: {}", e),
    }

    // Example 5: Get match details
    println!("\nFetching match details...");
    match client.get_match("match-id-here").await {
        Ok(match_details) => {
            println!("Match ID: {}", match_details.match_id);
            println!("Game: {}", match_details.game);
            println!("Status: {}", match_details.status);
        }
        Err(e) => eprintln!("Error fetching match: {}", e),
    }

    // Example 6: Get match stats
    println!("\nFetching match stats...");
    match client.get_match_stats("match-id-here").await {
        Ok(stats) => {
            println!("Rounds: {}", stats.rounds.len());
        }
        Err(e) => eprintln!("Error fetching match stats: {}", e),
    }

    // Example 7: Search for players
    println!("\nSearching for players...");
    match client
        .search_players("player_name", Some("cs2"), None, Some(0), Some(20))
        .await
    {
        Ok(results) => {
            println!("Found {} players", results.items.len());
            for player in results.items.iter().take(5) {
                println!("  - {} ({})", player.nickname, player.player_id);
            }
        }
        Err(e) => eprintln!("Error searching players: {}", e),
    }

    // Example 8: Get all games
    println!("\nFetching all games...");
    match client.get_all_games(Some(0), Some(20)).await {
        Ok(games) => {
            println!("Found {} games", games.items.len());
            for game in games.items.iter().take(5) {
                println!("  - {} ({})", game.long_label, game.game_id);
            }
        }
        Err(e) => eprintln!("Error fetching games: {}", e),
    }

    // Example 9: Get hub details
    println!("\nFetching hub details...");
    match client.get_hub("hub-id-here", None).await {
        Ok(hub) => {
            println!("Hub: {}", hub.name);
            println!("Game: {}", hub.game_id);
        }
        Err(e) => eprintln!("Error fetching hub: {}", e),
    }

    // Example 10: Get global ranking
    println!("\nFetching global ranking...");
    match client
        .get_global_ranking("cs2", "EU", None, Some(0), Some(20))
        .await
    {
        Ok(ranking) => {
            println!("Found {} players in ranking", ranking.items.len());
            for entry in ranking.items.iter().take(5) {
                println!(
                    "  {}: {} - ELO: {}",
                    entry.position, entry.nickname, entry.faceit_elo
                );
            }
        }
        Err(e) => eprintln!("Error fetching ranking: {}", e),
    }

    // Example 11: Using the builder pattern with authentication
    println!("\nCreating client with builder...");
    let _custom_client = HttpClient::builder()
        .api_key("your-api-key-or-access-token-here")
        .timeout(std::time::Duration::from_secs(60))
        .build()?;

    println!("Client created with custom configuration");

    Ok(())
}

pub async fn get_player_bans( &self, player_id: &str, offset: Option<i64>, limit: Option<i64>, ) -> Result<PlayerBansList, Error>

Get player bans

Arguments

• player_id - The FACEIT player ID
• offset - Optional offset for pagination (default: 0)
• limit - Optional limit for pagination (default: 20, max: 100)

Examples

let client = HttpClient::new();
let bans = client.get_player_bans("player-id", Some(0), Some(20)).await?;

pub async fn get_player_hubs( &self, player_id: &str, offset: Option<i64>, limit: Option<i64>, ) -> Result<HubsList, Error>

Get player hubs

Arguments

• player_id - The FACEIT player ID
• offset - Optional offset for pagination (default: 0, max: 1000)
• limit - Optional limit for pagination (default: 50, max: 50)

Examples

let client = HttpClient::new();
let hubs = client.get_player_hubs("player-id", Some(0), Some(50)).await?;

pub async fn get_player_teams( &self, player_id: &str, offset: Option<i64>, limit: Option<i64>, ) -> Result<TeamList, Error>

Get player teams

Arguments

• player_id - The FACEIT player ID
• offset - Optional offset for pagination (default: 0)
• limit - Optional limit for pagination (default: 20, max: 100)

Examples

let client = HttpClient::new();
let teams = client.get_player_teams("player-id", Some(0), Some(20)).await?;

pub async fn get_player_tournaments( &self, player_id: &str, offset: Option<i64>, limit: Option<i64>, ) -> Result<TournamentsList, Error>

Get player tournaments

Arguments

• player_id - The FACEIT player ID
• offset - Optional offset for pagination (default: 0)
• limit - Optional limit for pagination (default: 20, max: 100)

Examples

let client = HttpClient::new();
let tournaments = client.get_player_tournaments("player-id", Some(0), Some(20)).await?;

pub async fn get_match(&self, match_id: &str) -> Result<Match, Error>

Get match details

Arguments

• match_id - The FACEIT match ID

Examples

let client = HttpClient::new();
let match_details = client.get_match("match-id-here").await?;

Examples found in repository

examples/basic_usage.rs (line 64)

async fn main() -> Result<(), faceit::error::Error> {
    // Create a client (without authentication)
    let client = HttpClient::new();

    // Or create a client with API key or access token:
    // let client = Client::builder()
    //     .api_key("your-api-key-or-access-token")
    //     .build()?;

    // Example 1: Get player by ID
    println!("Fetching player by ID...");
    match client.get_player("player-id-here").await {
        Ok(player) => {
            println!("Player: {}", player.nickname);
            if let Some(country) = player.country {
                println!("Country: {}", country);
            }
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 2: Get player from lookup by nickname
    println!("\nFetching player from lookup...");
    match client
        .get_player_from_lookup(Some("player_nickname"), Some("cs2"), None)
        .await
    {
        Ok(player) => {
            println!("Player: {}", player.nickname);
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 3: Get player stats
    println!("\nFetching player stats...");
    match client.get_player_stats("player-id-here", "cs2").await {
        Ok(stats) => {
            println!("Player ID: {}", stats.player_id);
            println!("Game ID: {}", stats.game_id);
        }
        Err(e) => eprintln!("Error fetching stats: {}", e),
    }

    // Example 4: Get player match history
    println!("\nFetching player match history...");
    match client
        .get_player_history("player-id-here", "cs2", None, None, Some(0), Some(20))
        .await
    {
        Ok(history) => {
            println!("Found {} matches", history.items.len());
            if let Some(first_match) = history.items.first() {
                println!("Most recent match: {}", first_match.match_id);
            }
        }
        Err(e) => eprintln!("Error fetching history: {}", e),
    }

    // Example 5: Get match details
    println!("\nFetching match details...");
    match client.get_match("match-id-here").await {
        Ok(match_details) => {
            println!("Match ID: {}", match_details.match_id);
            println!("Game: {}", match_details.game);
            println!("Status: {}", match_details.status);
        }
        Err(e) => eprintln!("Error fetching match: {}", e),
    }

    // Example 6: Get match stats
    println!("\nFetching match stats...");
    match client.get_match_stats("match-id-here").await {
        Ok(stats) => {
            println!("Rounds: {}", stats.rounds.len());
        }
        Err(e) => eprintln!("Error fetching match stats: {}", e),
    }

    // Example 7: Search for players
    println!("\nSearching for players...");
    match client
        .search_players("player_name", Some("cs2"), None, Some(0), Some(20))
        .await
    {
        Ok(results) => {
            println!("Found {} players", results.items.len());
            for player in results.items.iter().take(5) {
                println!("  - {} ({})", player.nickname, player.player_id);
            }
        }
        Err(e) => eprintln!("Error searching players: {}", e),
    }

    // Example 8: Get all games
    println!("\nFetching all games...");
    match client.get_all_games(Some(0), Some(20)).await {
        Ok(games) => {
            println!("Found {} games", games.items.len());
            for game in games.items.iter().take(5) {
                println!("  - {} ({})", game.long_label, game.game_id);
            }
        }
        Err(e) => eprintln!("Error fetching games: {}", e),
    }

    // Example 9: Get hub details
    println!("\nFetching hub details...");
    match client.get_hub("hub-id-here", None).await {
        Ok(hub) => {
            println!("Hub: {}", hub.name);
            println!("Game: {}", hub.game_id);
        }
        Err(e) => eprintln!("Error fetching hub: {}", e),
    }

    // Example 10: Get global ranking
    println!("\nFetching global ranking...");
    match client
        .get_global_ranking("cs2", "EU", None, Some(0), Some(20))
        .await
    {
        Ok(ranking) => {
            println!("Found {} players in ranking", ranking.items.len());
            for entry in ranking.items.iter().take(5) {
                println!(
                    "  {}: {} - ELO: {}",
                    entry.position, entry.nickname, entry.faceit_elo
                );
            }
        }
        Err(e) => eprintln!("Error fetching ranking: {}", e),
    }

    // Example 11: Using the builder pattern with authentication
    println!("\nCreating client with builder...");
    let _custom_client = HttpClient::builder()
        .api_key("your-api-key-or-access-token-here")
        .timeout(std::time::Duration::from_secs(60))
        .build()?;

    println!("Client created with custom configuration");

    Ok(())
}

pub async fn get_match_stats(&self, match_id: &str) -> Result<MatchStats, Error>

Get match statistics

Arguments

• match_id - The FACEIT match ID

Examples

let client = HttpClient::new();
let stats = client.get_match_stats("match-id-here").await?;

Examples found in repository

examples/basic_usage.rs (line 75)

async fn main() -> Result<(), faceit::error::Error> {
    // Create a client (without authentication)
    let client = HttpClient::new();

    // Or create a client with API key or access token:
    // let client = Client::builder()
    //     .api_key("your-api-key-or-access-token")
    //     .build()?;

    // Example 1: Get player by ID
    println!("Fetching player by ID...");
    match client.get_player("player-id-here").await {
        Ok(player) => {
            println!("Player: {}", player.nickname);
            if let Some(country) = player.country {
                println!("Country: {}", country);
            }
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 2: Get player from lookup by nickname
    println!("\nFetching player from lookup...");
    match client
        .get_player_from_lookup(Some("player_nickname"), Some("cs2"), None)
        .await
    {
        Ok(player) => {
            println!("Player: {}", player.nickname);
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 3: Get player stats
    println!("\nFetching player stats...");
    match client.get_player_stats("player-id-here", "cs2").await {
        Ok(stats) => {
            println!("Player ID: {}", stats.player_id);
            println!("Game ID: {}", stats.game_id);
        }
        Err(e) => eprintln!("Error fetching stats: {}", e),
    }

    // Example 4: Get player match history
    println!("\nFetching player match history...");
    match client
        .get_player_history("player-id-here", "cs2", None, None, Some(0), Some(20))
        .await
    {
        Ok(history) => {
            println!("Found {} matches", history.items.len());
            if let Some(first_match) = history.items.first() {
                println!("Most recent match: {}", first_match.match_id);
            }
        }
        Err(e) => eprintln!("Error fetching history: {}", e),
    }

    // Example 5: Get match details
    println!("\nFetching match details...");
    match client.get_match("match-id-here").await {
        Ok(match_details) => {
            println!("Match ID: {}", match_details.match_id);
            println!("Game: {}", match_details.game);
            println!("Status: {}", match_details.status);
        }
        Err(e) => eprintln!("Error fetching match: {}", e),
    }

    // Example 6: Get match stats
    println!("\nFetching match stats...");
    match client.get_match_stats("match-id-here").await {
        Ok(stats) => {
            println!("Rounds: {}", stats.rounds.len());
        }
        Err(e) => eprintln!("Error fetching match stats: {}", e),
    }

    // Example 7: Search for players
    println!("\nSearching for players...");
    match client
        .search_players("player_name", Some("cs2"), None, Some(0), Some(20))
        .await
    {
        Ok(results) => {
            println!("Found {} players", results.items.len());
            for player in results.items.iter().take(5) {
                println!("  - {} ({})", player.nickname, player.player_id);
            }
        }
        Err(e) => eprintln!("Error searching players: {}", e),
    }

    // Example 8: Get all games
    println!("\nFetching all games...");
    match client.get_all_games(Some(0), Some(20)).await {
        Ok(games) => {
            println!("Found {} games", games.items.len());
            for game in games.items.iter().take(5) {
                println!("  - {} ({})", game.long_label, game.game_id);
            }
        }
        Err(e) => eprintln!("Error fetching games: {}", e),
    }

    // Example 9: Get hub details
    println!("\nFetching hub details...");
    match client.get_hub("hub-id-here", None).await {
        Ok(hub) => {
            println!("Hub: {}", hub.name);
            println!("Game: {}", hub.game_id);
        }
        Err(e) => eprintln!("Error fetching hub: {}", e),
    }

    // Example 10: Get global ranking
    println!("\nFetching global ranking...");
    match client
        .get_global_ranking("cs2", "EU", None, Some(0), Some(20))
        .await
    {
        Ok(ranking) => {
            println!("Found {} players in ranking", ranking.items.len());
            for entry in ranking.items.iter().take(5) {
                println!(
                    "  {}: {} - ELO: {}",
                    entry.position, entry.nickname, entry.faceit_elo
                );
            }
        }
        Err(e) => eprintln!("Error fetching ranking: {}", e),
    }

    // Example 11: Using the builder pattern with authentication
    println!("\nCreating client with builder...");
    let _custom_client = HttpClient::builder()
        .api_key("your-api-key-or-access-token-here")
        .timeout(std::time::Duration::from_secs(60))
        .build()?;

    println!("Client created with custom configuration");

    Ok(())
}

pub async fn get_all_games( &self, offset: Option<i64>, limit: Option<i64>, ) -> Result<GamesList, Error>

Get all games

Arguments

• offset - Optional offset for pagination (default: 0)
• limit - Optional limit for pagination (default: 20, max: 100)

Examples

let client = HttpClient::new();
let games = client.get_all_games(Some(0), Some(20)).await?;

Examples found in repository

examples/basic_usage.rs (line 99)

async fn main() -> Result<(), faceit::error::Error> {
    // Create a client (without authentication)
    let client = HttpClient::new();

    // Or create a client with API key or access token:
    // let client = Client::builder()
    //     .api_key("your-api-key-or-access-token")
    //     .build()?;

    // Example 1: Get player by ID
    println!("Fetching player by ID...");
    match client.get_player("player-id-here").await {
        Ok(player) => {
            println!("Player: {}", player.nickname);
            if let Some(country) = player.country {
                println!("Country: {}", country);
            }
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 2: Get player from lookup by nickname
    println!("\nFetching player from lookup...");
    match client
        .get_player_from_lookup(Some("player_nickname"), Some("cs2"), None)
        .await
    {
        Ok(player) => {
            println!("Player: {}", player.nickname);
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 3: Get player stats
    println!("\nFetching player stats...");
    match client.get_player_stats("player-id-here", "cs2").await {
        Ok(stats) => {
            println!("Player ID: {}", stats.player_id);
            println!("Game ID: {}", stats.game_id);
        }
        Err(e) => eprintln!("Error fetching stats: {}", e),
    }

    // Example 4: Get player match history
    println!("\nFetching player match history...");
    match client
        .get_player_history("player-id-here", "cs2", None, None, Some(0), Some(20))
        .await
    {
        Ok(history) => {
            println!("Found {} matches", history.items.len());
            if let Some(first_match) = history.items.first() {
                println!("Most recent match: {}", first_match.match_id);
            }
        }
        Err(e) => eprintln!("Error fetching history: {}", e),
    }

    // Example 5: Get match details
    println!("\nFetching match details...");
    match client.get_match("match-id-here").await {
        Ok(match_details) => {
            println!("Match ID: {}", match_details.match_id);
            println!("Game: {}", match_details.game);
            println!("Status: {}", match_details.status);
        }
        Err(e) => eprintln!("Error fetching match: {}", e),
    }

    // Example 6: Get match stats
    println!("\nFetching match stats...");
    match client.get_match_stats("match-id-here").await {
        Ok(stats) => {
            println!("Rounds: {}", stats.rounds.len());
        }
        Err(e) => eprintln!("Error fetching match stats: {}", e),
    }

    // Example 7: Search for players
    println!("\nSearching for players...");
    match client
        .search_players("player_name", Some("cs2"), None, Some(0), Some(20))
        .await
    {
        Ok(results) => {
            println!("Found {} players", results.items.len());
            for player in results.items.iter().take(5) {
                println!("  - {} ({})", player.nickname, player.player_id);
            }
        }
        Err(e) => eprintln!("Error searching players: {}", e),
    }

    // Example 8: Get all games
    println!("\nFetching all games...");
    match client.get_all_games(Some(0), Some(20)).await {
        Ok(games) => {
            println!("Found {} games", games.items.len());
            for game in games.items.iter().take(5) {
                println!("  - {} ({})", game.long_label, game.game_id);
            }
        }
        Err(e) => eprintln!("Error fetching games: {}", e),
    }

    // Example 9: Get hub details
    println!("\nFetching hub details...");
    match client.get_hub("hub-id-here", None).await {
        Ok(hub) => {
            println!("Hub: {}", hub.name);
            println!("Game: {}", hub.game_id);
        }
        Err(e) => eprintln!("Error fetching hub: {}", e),
    }

    // Example 10: Get global ranking
    println!("\nFetching global ranking...");
    match client
        .get_global_ranking("cs2", "EU", None, Some(0), Some(20))
        .await
    {
        Ok(ranking) => {
            println!("Found {} players in ranking", ranking.items.len());
            for entry in ranking.items.iter().take(5) {
                println!(
                    "  {}: {} - ELO: {}",
                    entry.position, entry.nickname, entry.faceit_elo
                );
            }
        }
        Err(e) => eprintln!("Error fetching ranking: {}", e),
    }

    // Example 11: Using the builder pattern with authentication
    println!("\nCreating client with builder...");
    let _custom_client = HttpClient::builder()
        .api_key("your-api-key-or-access-token-here")
        .timeout(std::time::Duration::from_secs(60))
        .build()?;

    println!("Client created with custom configuration");

    Ok(())
}

pub async fn get_game(&self, game_id: &str) -> Result<Game, Error>

Get game details

Arguments

• game_id - The game ID (e.g., “cs2”, “csgo”)

Examples

let client = HttpClient::new();
let game = client.get_game("cs2").await?;

pub async fn get_parent_game(&self, game_id: &str) -> Result<Game, Error>

Get parent game details (for region-specific games)

Arguments

• game_id - The game ID

Examples

let client = HttpClient::new();
let parent_game = client.get_parent_game("game-id").await?;

pub async fn get_game_matchmakings( &self, game_id: &str, region: Option<&str>, offset: Option<i64>, limit: Option<i64>, ) -> Result<MatchmakingList, Error>

Get game matchmakings

Arguments

• game_id - The game ID
• region - Optional region filter
• offset - Optional offset for pagination (default: 0)
• limit - Optional limit for pagination (default: 20, max: 100)

Examples

let client = HttpClient::new();
let matchmakings = client.get_game_matchmakings("cs2", Some("EU"), Some(0), Some(20)).await?;

pub async fn get_hub( &self, hub_id: &str, expanded: Option<&[&str]>, ) -> Result<Hub, Error>

Get hub details

Arguments

• hub_id - The hub ID
• expanded - Optional list of entities to expand (e.g., [“organizer”, “game”])

Examples

let client = HttpClient::new();
let hub = client.get_hub("hub-id", None).await?;

Examples found in repository

examples/basic_usage.rs (line 111)

async fn main() -> Result<(), faceit::error::Error> {
    // Create a client (without authentication)
    let client = HttpClient::new();

    // Or create a client with API key or access token:
    // let client = Client::builder()
    //     .api_key("your-api-key-or-access-token")
    //     .build()?;

    // Example 1: Get player by ID
    println!("Fetching player by ID...");
    match client.get_player("player-id-here").await {
        Ok(player) => {
            println!("Player: {}", player.nickname);
            if let Some(country) = player.country {
                println!("Country: {}", country);
            }
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 2: Get player from lookup by nickname
    println!("\nFetching player from lookup...");
    match client
        .get_player_from_lookup(Some("player_nickname"), Some("cs2"), None)
        .await
    {
        Ok(player) => {
            println!("Player: {}", player.nickname);
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 3: Get player stats
    println!("\nFetching player stats...");
    match client.get_player_stats("player-id-here", "cs2").await {
        Ok(stats) => {
            println!("Player ID: {}", stats.player_id);
            println!("Game ID: {}", stats.game_id);
        }
        Err(e) => eprintln!("Error fetching stats: {}", e),
    }

    // Example 4: Get player match history
    println!("\nFetching player match history...");
    match client
        .get_player_history("player-id-here", "cs2", None, None, Some(0), Some(20))
        .await
    {
        Ok(history) => {
            println!("Found {} matches", history.items.len());
            if let Some(first_match) = history.items.first() {
                println!("Most recent match: {}", first_match.match_id);
            }
        }
        Err(e) => eprintln!("Error fetching history: {}", e),
    }

    // Example 5: Get match details
    println!("\nFetching match details...");
    match client.get_match("match-id-here").await {
        Ok(match_details) => {
            println!("Match ID: {}", match_details.match_id);
            println!("Game: {}", match_details.game);
            println!("Status: {}", match_details.status);
        }
        Err(e) => eprintln!("Error fetching match: {}", e),
    }

    // Example 6: Get match stats
    println!("\nFetching match stats...");
    match client.get_match_stats("match-id-here").await {
        Ok(stats) => {
            println!("Rounds: {}", stats.rounds.len());
        }
        Err(e) => eprintln!("Error fetching match stats: {}", e),
    }

    // Example 7: Search for players
    println!("\nSearching for players...");
    match client
        .search_players("player_name", Some("cs2"), None, Some(0), Some(20))
        .await
    {
        Ok(results) => {
            println!("Found {} players", results.items.len());
            for player in results.items.iter().take(5) {
                println!("  - {} ({})", player.nickname, player.player_id);
            }
        }
        Err(e) => eprintln!("Error searching players: {}", e),
    }

    // Example 8: Get all games
    println!("\nFetching all games...");
    match client.get_all_games(Some(0), Some(20)).await {
        Ok(games) => {
            println!("Found {} games", games.items.len());
            for game in games.items.iter().take(5) {
                println!("  - {} ({})", game.long_label, game.game_id);
            }
        }
        Err(e) => eprintln!("Error fetching games: {}", e),
    }

    // Example 9: Get hub details
    println!("\nFetching hub details...");
    match client.get_hub("hub-id-here", None).await {
        Ok(hub) => {
            println!("Hub: {}", hub.name);
            println!("Game: {}", hub.game_id);
        }
        Err(e) => eprintln!("Error fetching hub: {}", e),
    }

    // Example 10: Get global ranking
    println!("\nFetching global ranking...");
    match client
        .get_global_ranking("cs2", "EU", None, Some(0), Some(20))
        .await
    {
        Ok(ranking) => {
            println!("Found {} players in ranking", ranking.items.len());
            for entry in ranking.items.iter().take(5) {
                println!(
                    "  {}: {} - ELO: {}",
                    entry.position, entry.nickname, entry.faceit_elo
                );
            }
        }
        Err(e) => eprintln!("Error fetching ranking: {}", e),
    }

    // Example 11: Using the builder pattern with authentication
    println!("\nCreating client with builder...");
    let _custom_client = HttpClient::builder()
        .api_key("your-api-key-or-access-token-here")
        .timeout(std::time::Duration::from_secs(60))
        .build()?;

    println!("Client created with custom configuration");

    Ok(())
}

pub async fn get_hub_matches( &self, hub_id: &str, match_type: Option<&str>, offset: Option<i64>, limit: Option<i64>, ) -> Result<MatchesList, Error>

Get hub matches

Arguments

• hub_id - The hub ID
• match_type - Optional match type filter (“all”, “upcoming”, “ongoing”, “past”)
• offset - Optional offset for pagination (default: 0)
• limit - Optional limit for pagination (default: 20, max: 100)

Examples

let client = HttpClient::new();
let matches = client.get_hub_matches("hub-id", Some("all"), Some(0), Some(20)).await?;

pub async fn get_hub_members( &self, hub_id: &str, offset: Option<i64>, limit: Option<i64>, ) -> Result<HubMembers, Error>

Get hub members

Arguments

• hub_id - The hub ID
• offset - Optional offset for pagination (default: 0, max: 1000)
• limit - Optional limit for pagination (default: 50, max: 50)

Examples

let client = HttpClient::new();
let members = client.get_hub_members("hub-id", Some(0), Some(50)).await?;

pub async fn get_hub_stats( &self, hub_id: &str, offset: Option<i64>, limit: Option<i64>, ) -> Result<HubStats, Error>

Get hub statistics

Arguments

• hub_id - The hub ID
• offset - Optional offset for pagination (default: 0)
• limit - Optional limit for pagination (default: 20, max: 100)

Examples

let client = HttpClient::new();
let stats = client.get_hub_stats("hub-id", Some(0), Some(20)).await?;

pub async fn get_championships( &self, game: &str, championship_type: Option<&str>, offset: Option<i64>, limit: Option<i64>, ) -> Result<ChampionshipsList, Error>

Get championships for a game

Arguments

• game - The game ID (required)
• championship_type - Optional type filter (“all”, “upcoming”, “ongoing”, “past”)
• offset - Optional offset for pagination (default: 0)
• limit - Optional limit for pagination (default: 10, max: 10)

Examples

let client = HttpClient::new();
let championships = client.get_championships("cs2", Some("all"), Some(0), Some(10)).await?;

pub async fn get_championship( &self, championship_id: &str, expanded: Option<&[&str]>, ) -> Result<Championship, Error>

Get championship details

Arguments

• championship_id - The championship ID
• expanded - Optional list of entities to expand (e.g., [“organizer”, “game”])

Examples

let client = HttpClient::new();
let championship = client.get_championship("championship-id", None).await?;

pub async fn get_championship_matches( &self, championship_id: &str, match_type: Option<&str>, offset: Option<i64>, limit: Option<i64>, ) -> Result<MatchesList, Error>

Get championship matches

Arguments

• championship_id - The championship ID
• match_type - Optional match type filter (“all”, “upcoming”, “ongoing”, “past”)
• offset - Optional offset for pagination (default: 0)
• limit - Optional limit for pagination (default: 20, max: 100)

Examples

let client = HttpClient::new();
let matches = client.get_championship_matches("championship-id", Some("all"), Some(0), Some(20)).await?;

pub async fn search_players( &self, nickname: &str, game: Option<&str>, country: Option<&str>, offset: Option<i64>, limit: Option<i64>, ) -> Result<UsersSearchList, Error>

Search for players

Arguments

• nickname - Player nickname to search for (required)
• game - Optional game ID filter
• country - Optional country code filter (ISO 3166-1)
• offset - Optional offset for pagination (default: 0)
• limit - Optional limit for pagination (default: 20, max: 100)

Examples

let client = HttpClient::new();
let results = client.search_players("player_name", Some("cs2"), None, Some(0), Some(20)).await?;

Examples found in repository

examples/basic_usage.rs (line 85)

async fn main() -> Result<(), faceit::error::Error> {
    // Create a client (without authentication)
    let client = HttpClient::new();

    // Or create a client with API key or access token:
    // let client = Client::builder()
    //     .api_key("your-api-key-or-access-token")
    //     .build()?;

    // Example 1: Get player by ID
    println!("Fetching player by ID...");
    match client.get_player("player-id-here").await {
        Ok(player) => {
            println!("Player: {}", player.nickname);
            if let Some(country) = player.country {
                println!("Country: {}", country);
            }
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 2: Get player from lookup by nickname
    println!("\nFetching player from lookup...");
    match client
        .get_player_from_lookup(Some("player_nickname"), Some("cs2"), None)
        .await
    {
        Ok(player) => {
            println!("Player: {}", player.nickname);
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 3: Get player stats
    println!("\nFetching player stats...");
    match client.get_player_stats("player-id-here", "cs2").await {
        Ok(stats) => {
            println!("Player ID: {}", stats.player_id);
            println!("Game ID: {}", stats.game_id);
        }
        Err(e) => eprintln!("Error fetching stats: {}", e),
    }

    // Example 4: Get player match history
    println!("\nFetching player match history...");
    match client
        .get_player_history("player-id-here", "cs2", None, None, Some(0), Some(20))
        .await
    {
        Ok(history) => {
            println!("Found {} matches", history.items.len());
            if let Some(first_match) = history.items.first() {
                println!("Most recent match: {}", first_match.match_id);
            }
        }
        Err(e) => eprintln!("Error fetching history: {}", e),
    }

    // Example 5: Get match details
    println!("\nFetching match details...");
    match client.get_match("match-id-here").await {
        Ok(match_details) => {
            println!("Match ID: {}", match_details.match_id);
            println!("Game: {}", match_details.game);
            println!("Status: {}", match_details.status);
        }
        Err(e) => eprintln!("Error fetching match: {}", e),
    }

    // Example 6: Get match stats
    println!("\nFetching match stats...");
    match client.get_match_stats("match-id-here").await {
        Ok(stats) => {
            println!("Rounds: {}", stats.rounds.len());
        }
        Err(e) => eprintln!("Error fetching match stats: {}", e),
    }

    // Example 7: Search for players
    println!("\nSearching for players...");
    match client
        .search_players("player_name", Some("cs2"), None, Some(0), Some(20))
        .await
    {
        Ok(results) => {
            println!("Found {} players", results.items.len());
            for player in results.items.iter().take(5) {
                println!("  - {} ({})", player.nickname, player.player_id);
            }
        }
        Err(e) => eprintln!("Error searching players: {}", e),
    }

    // Example 8: Get all games
    println!("\nFetching all games...");
    match client.get_all_games(Some(0), Some(20)).await {
        Ok(games) => {
            println!("Found {} games", games.items.len());
            for game in games.items.iter().take(5) {
                println!("  - {} ({})", game.long_label, game.game_id);
            }
        }
        Err(e) => eprintln!("Error fetching games: {}", e),
    }

    // Example 9: Get hub details
    println!("\nFetching hub details...");
    match client.get_hub("hub-id-here", None).await {
        Ok(hub) => {
            println!("Hub: {}", hub.name);
            println!("Game: {}", hub.game_id);
        }
        Err(e) => eprintln!("Error fetching hub: {}", e),
    }

    // Example 10: Get global ranking
    println!("\nFetching global ranking...");
    match client
        .get_global_ranking("cs2", "EU", None, Some(0), Some(20))
        .await
    {
        Ok(ranking) => {
            println!("Found {} players in ranking", ranking.items.len());
            for entry in ranking.items.iter().take(5) {
                println!(
                    "  {}: {} - ELO: {}",
                    entry.position, entry.nickname, entry.faceit_elo
                );
            }
        }
        Err(e) => eprintln!("Error fetching ranking: {}", e),
    }

    // Example 11: Using the builder pattern with authentication
    println!("\nCreating client with builder...");
    let _custom_client = HttpClient::builder()
        .api_key("your-api-key-or-access-token-here")
        .timeout(std::time::Duration::from_secs(60))
        .build()?;

    println!("Client created with custom configuration");

    Ok(())
}

pub async fn search_teams( &self, nickname: &str, game: Option<&str>, offset: Option<i64>, limit: Option<i64>, ) -> Result<TeamsSearchList, Error>

Search for teams

Arguments

• nickname - Team nickname to search for (required)
• game - Optional game ID filter
• offset - Optional offset for pagination (default: 0)
• limit - Optional limit for pagination (default: 20, max: 100)

Examples

let client = HttpClient::new();
let results = client.search_teams("team_name", Some("cs2"), Some(0), Some(20)).await?;

pub async fn search_hubs( &self, name: &str, game: Option<&str>, region: Option<&str>, offset: Option<i64>, limit: Option<i64>, ) -> Result<CompetitionsSearchList, Error>

Search for hubs

Arguments

• name - Hub name to search for (required)
• game - Optional game ID filter
• region - Optional region filter
• offset - Optional offset for pagination (default: 0)
• limit - Optional limit for pagination (default: 20, max: 100)

Examples

let client = HttpClient::new();
let results = client.search_hubs("hub_name", Some("cs2"), Some("EU"), Some(0), Some(20)).await?;

pub async fn get_global_ranking( &self, game_id: &str, region: &str, country: Option<&str>, offset: Option<i64>, limit: Option<i64>, ) -> Result<GlobalRankingList, Error>

Get global ranking for a game and region

Arguments

• game_id - The game ID
• region - The region (required)
• country - Optional country code filter (ISO 3166-1)
• offset - Optional offset for pagination (default: 0)
• limit - Optional limit for pagination (default: 20, max: 100)

Examples

let client = HttpClient::new();
let ranking = client.get_global_ranking("cs2", "EU", None, Some(0), Some(20)).await?;

Examples found in repository

examples/basic_usage.rs (line 122)

async fn main() -> Result<(), faceit::error::Error> {
    // Create a client (without authentication)
    let client = HttpClient::new();

    // Or create a client with API key or access token:
    // let client = Client::builder()
    //     .api_key("your-api-key-or-access-token")
    //     .build()?;

    // Example 1: Get player by ID
    println!("Fetching player by ID...");
    match client.get_player("player-id-here").await {
        Ok(player) => {
            println!("Player: {}", player.nickname);
            if let Some(country) = player.country {
                println!("Country: {}", country);
            }
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 2: Get player from lookup by nickname
    println!("\nFetching player from lookup...");
    match client
        .get_player_from_lookup(Some("player_nickname"), Some("cs2"), None)
        .await
    {
        Ok(player) => {
            println!("Player: {}", player.nickname);
        }
        Err(e) => eprintln!("Error fetching player: {}", e),
    }

    // Example 3: Get player stats
    println!("\nFetching player stats...");
    match client.get_player_stats("player-id-here", "cs2").await {
        Ok(stats) => {
            println!("Player ID: {}", stats.player_id);
            println!("Game ID: {}", stats.game_id);
        }
        Err(e) => eprintln!("Error fetching stats: {}", e),
    }

    // Example 4: Get player match history
    println!("\nFetching player match history...");
    match client
        .get_player_history("player-id-here", "cs2", None, None, Some(0), Some(20))
        .await
    {
        Ok(history) => {
            println!("Found {} matches", history.items.len());
            if let Some(first_match) = history.items.first() {
                println!("Most recent match: {}", first_match.match_id);
            }
        }
        Err(e) => eprintln!("Error fetching history: {}", e),
    }

    // Example 5: Get match details
    println!("\nFetching match details...");
    match client.get_match("match-id-here").await {
        Ok(match_details) => {
            println!("Match ID: {}", match_details.match_id);
            println!("Game: {}", match_details.game);
            println!("Status: {}", match_details.status);
        }
        Err(e) => eprintln!("Error fetching match: {}", e),
    }

    // Example 6: Get match stats
    println!("\nFetching match stats...");
    match client.get_match_stats("match-id-here").await {
        Ok(stats) => {
            println!("Rounds: {}", stats.rounds.len());
        }
        Err(e) => eprintln!("Error fetching match stats: {}", e),
    }

    // Example 7: Search for players
    println!("\nSearching for players...");
    match client
        .search_players("player_name", Some("cs2"), None, Some(0), Some(20))
        .await
    {
        Ok(results) => {
            println!("Found {} players", results.items.len());
            for player in results.items.iter().take(5) {
                println!("  - {} ({})", player.nickname, player.player_id);
            }
        }
        Err(e) => eprintln!("Error searching players: {}", e),
    }

    // Example 8: Get all games
    println!("\nFetching all games...");
    match client.get_all_games(Some(0), Some(20)).await {
        Ok(games) => {
            println!("Found {} games", games.items.len());
            for game in games.items.iter().take(5) {
                println!("  - {} ({})", game.long_label, game.game_id);
            }
        }
        Err(e) => eprintln!("Error fetching games: {}", e),
    }

    // Example 9: Get hub details
    println!("\nFetching hub details...");
    match client.get_hub("hub-id-here", None).await {
        Ok(hub) => {
            println!("Hub: {}", hub.name);
            println!("Game: {}", hub.game_id);
        }
        Err(e) => eprintln!("Error fetching hub: {}", e),
    }

    // Example 10: Get global ranking
    println!("\nFetching global ranking...");
    match client
        .get_global_ranking("cs2", "EU", None, Some(0), Some(20))
        .await
    {
        Ok(ranking) => {
            println!("Found {} players in ranking", ranking.items.len());
            for entry in ranking.items.iter().take(5) {
                println!(
                    "  {}: {} - ELO: {}",
                    entry.position, entry.nickname, entry.faceit_elo
                );
            }
        }
        Err(e) => eprintln!("Error fetching ranking: {}", e),
    }

    // Example 11: Using the builder pattern with authentication
    println!("\nCreating client with builder...");
    let _custom_client = HttpClient::builder()
        .api_key("your-api-key-or-access-token-here")
        .timeout(std::time::Duration::from_secs(60))
        .build()?;

    println!("Client created with custom configuration");

    Ok(())
}

pub async fn get_player_ranking( &self, game_id: &str, region: &str, player_id: &str, country: Option<&str>, limit: Option<i64>, ) -> Result<PlayerGlobalRanking, Error>

Get player ranking in global ranking

Arguments

• game_id - The game ID
• region - The region (required)
• player_id - The player ID (required)
• country - Optional country code filter (ISO 3166-1)
• limit - Optional limit for pagination (default: 20, max: 100)

Examples

let client = HttpClient::new();
let ranking = client.get_player_ranking("cs2", "EU", "player-id", None, Some(20)).await?;

Trait Implementations

impl Default for Client

fn default() -> Self

Returns the “default value” for a type.