the-odds-api 0.1.1

A Rust SDK for The Odds API - sports odds and scores
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Type definitions for API parameters and enums.

use serde::{Deserialize, Serialize};
use std::fmt;

/// Region codes for bookmaker filtering.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Region {
    /// United States
    Us,
    /// United States (secondary)
    Us2,
    /// United Kingdom
    Uk,
    /// Australia
    Au,
    /// Europe
    Eu,
}

impl fmt::Display for Region {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Region::Us => write!(f, "us"),
            Region::Us2 => write!(f, "us2"),
            Region::Uk => write!(f, "uk"),
            Region::Au => write!(f, "au"),
            Region::Eu => write!(f, "eu"),
        }
    }
}

/// Market types for odds requests.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Market {
    /// Head to head (moneyline)
    H2h,
    /// Point spreads
    Spreads,
    /// Totals (over/under)
    Totals,
    /// Outright/futures
    Outrights,
    /// Head to head for draw (3-way)
    H2hLay,
    /// Custom/alternate market (for event odds endpoint)
    #[serde(untagged)]
    Custom(String),
}

impl fmt::Display for Market {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Market::H2h => write!(f, "h2h"),
            Market::Spreads => write!(f, "spreads"),
            Market::Totals => write!(f, "totals"),
            Market::Outrights => write!(f, "outrights"),
            Market::H2hLay => write!(f, "h2h_lay"),
            Market::Custom(s) => write!(f, "{}", s),
        }
    }
}

impl From<&str> for Market {
    fn from(s: &str) -> Self {
        match s {
            "h2h" => Market::H2h,
            "spreads" => Market::Spreads,
            "totals" => Market::Totals,
            "outrights" => Market::Outrights,
            "h2h_lay" => Market::H2hLay,
            other => Market::Custom(other.to_string()),
        }
    }
}

/// Date format for API responses.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum DateFormat {
    /// ISO 8601 format (default)
    #[default]
    Iso,
    /// Unix timestamp
    Unix,
}

impl fmt::Display for DateFormat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            DateFormat::Iso => write!(f, "iso"),
            DateFormat::Unix => write!(f, "unix"),
        }
    }
}

/// Odds format for API responses.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum OddsFormat {
    /// Decimal odds (default)
    #[default]
    Decimal,
    /// American odds
    American,
}

impl fmt::Display for OddsFormat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            OddsFormat::Decimal => write!(f, "decimal"),
            OddsFormat::American => write!(f, "american"),
        }
    }
}

/// Sport key type alias for clarity.
pub type SportKey = String;

/// Event ID type alias for clarity.
pub type EventId = String;

/// Helper to format a slice as comma-separated values.
pub(crate) fn format_csv<T: fmt::Display>(items: &[T]) -> String {
    items
        .iter()
        .map(|i| i.to_string())
        .collect::<Vec<_>>()
        .join(",")
}