use serde::{Deserialize, Serialize};
pub type UserId = String;
pub type RewardId = String;
pub type RedemptionId = String;
pub type UserName = Nickname;
pub type DisplayName = String;
pub type Nickname = String;
pub type Timestamp = String;
pub type CategoryId = String;
pub type TagId = String;
pub type VideoId = String;
pub type EventSubId = String;
#[derive(PartialEq, Deserialize, Debug, Clone)]
#[cfg_attr(not(feature = "allow_unknown_fields"), serde(deny_unknown_fields))]
#[non_exhaustive]
pub struct TwitchCategory {
pub box_art_url: String,
pub id: CategoryId,
pub name: String,
}
#[derive(PartialEq, Eq, Deserialize, Clone, Debug)]
#[serde(field_identifier)]
pub enum SubscriptionTier {
#[serde(rename = "1000")]
Tier1,
#[serde(rename = "2000")]
Tier2,
#[serde(rename = "3000")]
Tier3,
Prime,
Other(String),
}
impl Serialize for SubscriptionTier {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: serde::Serializer {
serializer.serialize_str(match self {
SubscriptionTier::Tier1 => "1000",
SubscriptionTier::Tier2 => "2000",
SubscriptionTier::Tier3 => "3000",
SubscriptionTier::Prime => "Prime",
SubscriptionTier::Other(o) => o,
})
}
}
#[derive(PartialEq, Deserialize, Clone, Debug)]
pub enum BroadcasterType {
#[serde(rename = "partner")]
Partner,
#[serde(rename = "affiliated")]
Affiliated,
#[serde(other)]
None,
}
impl Serialize for BroadcasterType {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: serde::Serializer {
serializer.serialize_str(match self {
BroadcasterType::Partner => "partner",
BroadcasterType::Affiliated => "affiliated",
BroadcasterType::None => "",
})
}
}
#[derive(PartialEq, Deserialize, Clone, Debug)]
pub enum UserType {
#[serde(rename = "staff")]
Staff,
#[serde(rename = "admin")]
Admin,
#[serde(rename = "global_mod")]
GlobalMod,
#[serde(other)]
None,
}
impl Serialize for UserType {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: serde::Serializer {
serializer.serialize_str(match self {
UserType::Staff => "staff",
UserType::Admin => "admin",
UserType::GlobalMod => "global_mod",
UserType::None => "",
})
}
}
#[derive(PartialEq, Deserialize, Serialize, Clone, Debug)]
#[serde(rename_all = "lowercase")]
pub enum VideoPeriod {
All,
Day,
Week,
Month,
}
#[derive(PartialEq, Eq, Deserialize, Serialize, Clone, Debug)]
#[serde(rename_all = "snake_case")]
pub enum VideoType {
Live,
Playlist,
Upload,
Archive,
Highlight,
Premiere,
Rerun,
WatchParty,
WatchPartyPremiere,
WatchPartyRerun,
}
#[derive(PartialEq, Eq, Deserialize, Serialize, Clone, Debug)]
#[serde(rename_all = "lowercase")]
pub enum VideoPrivacy {
Public,
Private,
}
#[derive(
displaydoc::Display,
serde_repr::Serialize_repr,
serde_repr::Deserialize_repr,
Debug,
Clone,
PartialEq,
Eq,
)]
#[repr(u64)]
#[non_exhaustive]
pub enum CommercialLength {
Length30 = 30,
Length60 = 60,
Length90 = 90,
Length120 = 120,
Length150 = 150,
Length180 = 180,
}
impl std::convert::TryFrom<u64> for CommercialLength {
type Error = CommercialLengthParseError;
fn try_from(l: u64) -> Result<Self, Self::Error> {
match l {
30 => Ok(CommercialLength::Length30),
60 => Ok(CommercialLength::Length60),
90 => Ok(CommercialLength::Length90),
120 => Ok(CommercialLength::Length120),
150 => Ok(CommercialLength::Length150),
180 => Ok(CommercialLength::Length180),
other => Err(CommercialLengthParseError::InvalidLength(other)),
}
}
}
#[derive(thiserror::Error, Debug, displaydoc::Display)]
pub enum CommercialLengthParseError {
InvalidLength(u64),
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct User {
#[serde(alias = "user_id")]
pub id: UserId,
#[serde(alias = "user_login")]
pub login: UserName,
#[serde(alias = "user_display_name")]
pub display_name: DisplayName,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(not(feature = "allow_unknown_fields"), serde(deny_unknown_fields))]
#[non_exhaustive]
pub struct Image {
pub url_1x: String,
pub url_2x: String,
pub url_4x: String,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(not(feature = "allow_unknown_fields"), serde(deny_unknown_fields))]
#[non_exhaustive]
pub struct GlobalCooldown {
pub is_enabled: bool,
#[serde(alias = "seconds")]
pub global_cooldown_seconds: u32,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(not(feature = "allow_unknown_fields"), serde(deny_unknown_fields))]
#[serde(untagged)]
#[non_exhaustive]
pub enum Max {
MaxPerStream {
is_enabled: bool,
#[serde(alias = "value")]
max_per_stream: u32,
},
MaxPerUserPerStream {
is_enabled: bool,
#[serde(alias = "value")]
max_per_user_per_stream: u32,
},
}