twitch_highway 0.5.2

Twitch API
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

use std::fmt::{Display, Formatter, Result as FmtResult};

use chrono::{DateTime, FixedOffset};
use serde::{Deserialize, Serialize};

use crate::types::{UserId, VideoId};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Video {
    pub id: VideoId,
    pub stream_id: Option<String>,
    pub user_id: UserId,
    pub user_login: String,
    pub user_name: String,
    pub title: String,
    pub description: String,
    pub created_at: DateTime<FixedOffset>,
    pub published_at: DateTime<FixedOffset>,
    pub url: String,
    pub thumbnail_url: String,
    pub viewable: String,
    pub view_count: u64,
    pub language: String,
    #[serde(rename = "type")]
    pub kind: Type,
    pub duration: String,
    pub muted_segments: Vec<MutedSegment>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MutedSegment {
    pub duration: u64,
    pub offset: u64,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Period {
    All,
    Day,
    Month,
    Week,
}

impl Period {
    pub fn as_str(&self) -> &str {
        match self {
            Self::All => "all",
            Self::Day => "day",
            Self::Month => "month",
            Self::Week => "week",
        }
    }
}

impl Display for Period {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        f.write_str(self.as_str())
    }
}

impl AsRef<str> for Period {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Sort {
    Time,
    Trending,
    Views,
}

impl Sort {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Time => "time",
            Self::Trending => "trending",
            Self::Views => "views",
        }
    }
}

impl AsRef<str> for Sort {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl Display for Sort {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        f.write_str(self.as_str())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Type {
    All,
    Archive,
    Highlight,
    Upload,
}

impl Type {
    pub fn as_str(&self) -> &str {
        match self {
            Self::All => "all",
            Self::Archive => "archive",
            Self::Highlight => "highlight",
            Self::Upload => "upload",
        }
    }
}

impl AsRef<str> for Type {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl Display for Type {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        f.write_str(self.as_str())
    }
}