1use crate::*;
2use crate::{Deserialise, Serialise};
3use serde_with::with_prefix;
4
5with_prefix!(pub prefix_broadcaster "broadcaster_");
6with_prefix!(pub prefix_from_broadcaster "from_broadcaster_");
7with_prefix!(pub prefix_to_broadcaster "to_broadcaster_");
8with_prefix!(pub prefix_requester "requester_");
9with_prefix!(pub prefix_request "request_");
10with_prefix!(pub prefix_thread "thread_");
11with_prefix!(pub prefix_parent "parent_");
12with_prefix!(pub prefix_chatter "chatter_");
13with_prefix!(pub prefix_target "target_");
14
15#[derive(Serialise, Deserialise, Clone, Debug)]
16pub struct TopContributions {
17 #[serde(flatten)]
18 pub user: User,
19 #[serde(rename = "type")]
20 pub kind: String,
21 pub total: u32,
22}
23
24#[derive(Serialise, Deserialise, Clone, Debug)]
25pub struct LastContribution {
26 #[serde(flatten)]
27 pub user: User,
28 #[serde(rename = "type")]
29 pub kind: String,
30 pub total: u32,
31}
32
33#[derive(Serialise, Deserialise, Clone, Debug)]
34pub struct HypeTrainEndData {
35 pub id: String,
36 #[serde(flatten, with = "prefix_broadcaster")]
37 pub broadcaster: User,
38 pub level: u32,
39 pub total: u32,
40 pub top_contributions: TopContributions,
41 pub started_at: String,
42 pub ended_at: String,
43 pub cooldown_ends_at: String,
44}
45
46#[derive(Serialise, Deserialise, Clone, Debug)]
47pub struct HypeTrainProgressData {
48 pub id: String,
49 #[serde(flatten, with = "prefix_broadcaster")]
50 pub broadcaster: User,
51 pub level: u32,
52 pub total: u32,
53 pub progress: u32,
54 pub goal: u32,
55 pub top_contributions: TopContributions,
56 pub last_contribution: LastContribution,
57 pub started_at: String,
58 pub expires_at: String,
59}
60
61#[derive(Serialise, Deserialise, Clone, Debug)]
62pub struct HypeTrainBeginData {
63 pub id: String,
64 #[serde(flatten, with = "prefix_broadcaster")]
65 pub broadcaster: User,
66 pub total: u32,
67 pub progress: u32,
68 pub top_contributions: TopContributions,
69 pub last_contribution: LastContribution,
70 pub level: u32,
71 pub started_at: String,
72 pub exires_at: String,
73}
74
75#[derive(Serialise, Deserialise, Clone, Debug)]
76pub struct TopPredictors {
77 #[serde(flatten)]
78 pub user: User,
79 pub channel_points_won: Option<u32>,
80 pub channel_points_used: u32,
81}
82
83#[derive(Serialise, Deserialise, Clone, Debug)]
84pub struct BeginOutcome {
85 id: String,
86 title: String,
87 #[serde(rename = "color")]
88 colour: String,
89}
90
91#[derive(Serialise, Deserialise, Clone, Debug)]
92pub struct Outcome {
93 pub id: String,
94 pub title: String,
95 #[serde(rename = "color")]
96 pub colour: String,
97 pub users: u32,
98 pub channel_points: u32,
99 pub top_predictors: Vec<TopPredictors>,
100}
101
102#[derive(Serialise, Deserialise, Clone, Debug)]
103pub struct PredictionBeginData {
104 pub id: String,
105 #[serde(flatten, with = "prefix_broadcaster")]
106 pub broadcaster: User,
107 pub title: String,
108 pub outcomes: Vec<BeginOutcome>,
109 pub started_at: String,
110 pub locks_at: String,
111}
112
113#[derive(Serialise, Deserialise, Clone, Debug)]
114pub struct PredicitonProgressData {
115 pub id: String,
116 #[serde(flatten, with = "prefix_broadcaster")]
117 broadcaster: User,
118 pub title: String,
119 pub outcomes: Vec<Outcome>,
120 pub started_at: String,
121 pub locks_at: String,
122}
123
124#[derive(Serialise, Deserialise, Clone, Debug)]
125pub struct PredictionLockData {
126 pub id: String,
127 #[serde(flatten, with = "prefix_broadcaster")]
128 pub broadcaster: User,
129 pub title: String,
130 pub outcomes: Vec<Outcome>,
131 pub started_at: String,
132 pub locked_at: String,
133}
134
135#[derive(Serialise, Deserialise, Clone, Debug)]
136pub struct PredicitionEndData {
137 pub id: String,
138 #[serde(flatten, with = "prefix_broadcaster")]
139 pub broadcaster: User,
140 pub title: String,
141 pub winning_outcome_id: String,
142 pub outcomes: Vec<Outcome>,
143 pub status: String,
144 pub started_at: String,
145 pub ended_at: String,
146}
147
148#[derive(Serialise, Deserialise, Clone, Debug)]
149pub struct GiftData {
150 #[serde(flatten)]
151 pub user: OptionalUser,
152 #[serde(flatten, with = "prefix_broadcaster")]
153 pub broadcaster: User,
154 pub total: u32,
155 pub tier: String,
156 pub cumulative_total: Option<u32>,
157 pub is_anonymous: bool,
158}
159
160#[derive(Serialise, Deserialise, Clone, Debug)]
161pub struct UnlockedEmote {
162 pub id: String,
163 pub name: String,
164}
165
166#[derive(Serialise, Deserialise, Clone, Debug)]
167pub struct RewardEmote {
168 pub id: String,
169 pub begin: u32,
170 pub end: u32,
171}
172
173#[derive(Serialise, Deserialise, Clone, Debug)]
174pub struct RewardMessageData {
175 pub text: String,
176 pub emotes: Option<Vec<RewardEmote>>,
177}
178
179#[derive(Serialise, Deserialise, Clone, Debug)]
180pub enum AutoRewardType {
181 #[serde(rename = "send_highlighted_message")]
182 SendHighlightedMessage,
183 #[serde(rename = "single_message_bypass_ub_mode")]
184 SingleMessageBypassSubMode,
185 #[serde(rename = "random_sub_emote_unlock")]
186 RandomSubEmoteUnlock,
187 #[serde(rename = "chosen_sub_emote_unlock")]
188 ChosenSubEmoteUnlock,
189 #[serde(rename = "chosen_modified_sub_emote_unlock")]
190 ChosenModifiedSubEmoteUnlock,
191 #[serde(rename = "message_effect")]
192 MessageEffect,
193 #[serde(rename = "gigantify_an_emote")]
194 GigantifyAnEmote,
195 #[serde(rename = "celebration")]
196 Celebration,
197}
198
199#[derive(Serialise, Deserialise, Clone, Debug)]
200pub struct AutoRewardData {
201 #[serde(rename = "type")]
202 pub kind: AutoRewardType,
203 pub cost: u32,
204 pub unlocked_emote: Option<UnlockedEmote>,
205}
206
207#[derive(Serialise, Deserialise, Clone, Debug)]
208pub struct ChannelPointsAutoRewardRedeemData {
209 #[serde(flatten, with = "prefix_broadcaster")]
210 pub broadcaster: User,
211 #[serde(flatten)]
212 pub user: User,
213 pub id: String,
214 pub reward: AutoRewardData,
215 pub message: RewardMessageData,
216 pub user_input: Option<String>,
217 pub redeemed_at: String,
218}
219
220#[derive(Serialise, Deserialise, Clone, Debug)]
221pub struct CheerData {
222 #[serde(flatten)]
223 pub user: User,
224 #[serde(flatten, with = "prefix_broadcaster")]
225 pub broadcaster: User,
226 pub is_anonymous: bool,
227 pub message: String,
228 pub bits: u32,
229}
230
231#[derive(Serialise, Deserialise, Clone, Debug)]
232pub struct FollowData {
233 #[serde(flatten)]
234 pub user: User,
235 #[serde(flatten, with = "prefix_broadcaster")]
236 pub broadcaster: User,
237 pub followed_at: String,
238}
239
240#[derive(Serialise, Deserialise, Clone, Debug)]
241pub struct NewSubscriptionData {
242 #[serde(flatten)]
243 pub user: User,
244 #[serde(flatten, with = "prefix_broadcaster")]
245 pub broadcaster: User,
246 pub tier: String,
247 pub is_gift: bool,
248}
249
250#[derive(Serialise, Deserialise, Clone, Debug)]
251pub struct ResubscriptionData {
252 #[serde(flatten)]
253 pub user: User,
254 #[serde(flatten, with = "prefix_broadcaster")]
255 pub broadcaster: User,
256 pub message: RewardMessageData,
257 pub tier: String,
258 pub cumulative_months: u32,
259 pub streak_months: Option<u32>,
260 pub duration_months: u32,
261}
262
263#[derive(Serialise, Deserialise, Clone, Debug)]
264pub struct OptionalUser {
265 #[serde(rename = "user_id")]
266 pub id: Option<String>,
267 #[serde(rename = "user_name")]
268 pub name: Option<String>,
269 #[serde(rename = "user_login")]
270 pub login: Option<String>,
271}
272
273#[repr(C)]
274#[derive(Serialise, Deserialise, Clone, Debug)]
275pub struct User {
276 #[serde(rename = "user_id")]
277 pub id: String,
278 #[serde(rename = "user_name")]
279 pub name: String,
280 #[serde(rename = "user_login")]
281 pub login: String,
282}
283
284#[derive(Serialise, Deserialise, Clone, Debug)]
285pub struct AdBreakBeginData {
286 #[serde(flatten, with = "prefix_broadcaster")]
287 pub broadcaster: User,
288 #[serde(flatten, with = "prefix_requester")]
289 pub requester: User,
290 pub duration_seconds: u32,
291 pub started_at: String,
292 pub is_automatic: bool,
293}
294
295#[repr(u8)]
296#[derive(Serialise, Deserialise, Clone, Debug)]
297pub enum MessageType {
298 #[serde(rename = "text")]
299 Text,
300 #[serde(rename = "channel_points_highlighted")]
301 ChannelPointsHighlighted,
302 #[serde(rename = "channel_points_sub_only")]
303 ChannelPointsSubOnly,
304 #[serde(rename = "user_intro")]
305 UserIntro,
306 #[serde(rename = "power_ups_message_effect")]
307 PowerUpsMessageEffect,
308 #[serde(rename = "power_ups_gigantified_emote")]
309 PowerUpsGigantifiedEmote,
310}
311
312#[repr(C)]
313#[derive(Serialise, Deserialise, Clone, Debug)]
314pub struct MessageData {
315 #[serde(flatten, with = "prefix_broadcaster")]
316 pub broadcaster: User,
317 #[serde(flatten, with = "prefix_chatter")]
318 pub chatter: User,
319 pub message_id: String,
320 pub message: Message,
321 #[serde(rename = "color")]
322 pub colour: String,
323 pub badges: Vec<Badge>,
324 pub message_type: MessageType,
325 pub cheer: Option<Cheer>,
326 pub reply: Option<Reply>,
327 pub channel_points_custom_reward_id: Option<String>,
328 pub channel_points_animation_id: Option<String>,
329}
330
331#[derive(Serialise, Deserialise, Clone, Debug)]
332pub struct RaidData {
333 #[serde(flatten, with = "prefix_from_broadcaster")]
334 pub from_broadcaster: User,
335 #[serde(flatten, with = "prefix_to_broadcaster")]
336 pub to_broadcaster: User,
337 pub viewers: u32,
338}
339
340#[derive(Serialise, Deserialise, Clone, Debug)]
341pub struct BitsVotingData {
342 pub is_enabled: bool,
343 pub amount_per_vote: u32,
344}
345
346#[derive(Serialise, Deserialise, Clone, Debug)]
347pub struct ChannelPointsVoting {
348 pub is_enabled: bool,
349 pub amount_per_vote: u32,
350}
351
352#[derive(Serialise, Deserialise, Clone, Debug)]
353pub struct Choices {
354 pub id: String,
355 pub title: String,
356 pub votes: u32,
357 pub channel_points_votes: u32,
358 pub bits_votes: u32,
359}
360
361#[derive(Serialise, Deserialise, Clone, Debug)]
362pub struct BeginChoices {
363 pub id: String,
364 pub title: String,
365}
366
367#[derive(Serialise, Deserialise, Clone, Debug)]
368pub struct PollEndData {
369 pub id: String,
370 #[serde(flatten, with = "prefix_broadcaster")]
371 pub broadcaster: User,
372 pub title: String,
373 pub choices: Vec<Choices>,
374 pub bits_voting: BitsVotingData,
375 pub channel_points_voting: ChannelPointsVoting,
376 pub started_at: String,
377 pub ended_at: String,
378 pub status: String,
379}
380
381#[derive(Serialise, Deserialise, Clone, Debug)]
382pub struct PollProgressData {
383 pub id: String,
384 #[serde(flatten, with = "prefix_broadcaster")]
385 pub broadcaster: User,
386 pub title: String,
387 pub choices: Vec<Choices>,
388 pub bits_voting: BitsVotingData,
389 pub channel_points_voting: ChannelPointsVoting,
390 pub started_at: String,
391 pub ends_at: String,
392}
393
394#[derive(Serialise, Deserialise, Clone, Debug)]
395pub struct PollBeginData {
396 pub id: String,
397 #[serde(flatten, with = "prefix_broadcaster")]
398 pub broadcaster: User,
399 pub title: String,
400 pub choices: Vec<BeginChoices>,
401 pub bits_voting: BitsVotingData,
402 pub channel_points_voting: ChannelPointsVoting,
403 pub started_at: String,
404 pub ends_at: String,
405}
406
407#[derive(Serialise, Deserialise, Clone, Debug)]
408pub struct CustomPointsRewardRedeemData {
409 pub id: String,
410 #[serde(flatten)]
411 pub user: User,
412 #[serde(flatten, with = "prefix_broadcaster")]
413 pub broadcaster: User,
414 pub user_input: String,
415 pub status: String,
416 pub reward: Reward,
417 pub redeemed_at: String,
418}
419
420#[derive(Serialise, Deserialise, Clone, Debug)]
421pub struct MessageDeletedData {
422 #[serde(flatten, with = "prefix_broadcaster")]
423 pub broadcaster: User,
424 #[serde(flatten, with = "prefix_target")]
425 pub target: User,
426 pub message_id: String,
427}