#[derive(Debug, Clone, serde::Serialize)]
pub struct PlayerCreatedParams {
#[serde(rename = "player")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub player: crate::media::types::Player,
}
impl<'de> serde::Deserialize<'de> for PlayerCreatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PlayerCreatedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "player")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub player: crate::media::types::Player,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PlayerCreatedParams {
player: fields.player,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct PlayerCreated;
impl ydp_core::Event for PlayerCreated {
type Params = PlayerCreatedParams;
const METHOD: &'static str = "Media.playerCreated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct PlayerErrorsRaisedParams {
#[serde(rename = "playerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub player_id: crate::media::types::PlayerId,
#[serde(rename = "errors")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub errors: Vec<crate::media::types::PlayerError>,
}
impl<'de> serde::Deserialize<'de> for PlayerErrorsRaisedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PlayerErrorsRaisedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "playerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub player_id: crate::media::types::PlayerId,
#[serde(rename = "errors")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub errors: Vec<crate::media::types::PlayerError>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PlayerErrorsRaisedParams {
player_id: fields.player_id,
errors: fields.errors,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct PlayerErrorsRaised;
impl ydp_core::Event for PlayerErrorsRaised {
type Params = PlayerErrorsRaisedParams;
const METHOD: &'static str = "Media.playerErrorsRaised";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct PlayerEventsAddedParams {
#[serde(rename = "playerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub player_id: crate::media::types::PlayerId,
#[serde(rename = "events")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub events: Vec<crate::media::types::PlayerEvent>,
}
impl<'de> serde::Deserialize<'de> for PlayerEventsAddedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PlayerEventsAddedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "playerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub player_id: crate::media::types::PlayerId,
#[serde(rename = "events")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub events: Vec<crate::media::types::PlayerEvent>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PlayerEventsAddedParams {
player_id: fields.player_id,
events: fields.events,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct PlayerEventsAdded;
impl ydp_core::Event for PlayerEventsAdded {
type Params = PlayerEventsAddedParams;
const METHOD: &'static str = "Media.playerEventsAdded";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct PlayerMessagesLoggedParams {
#[serde(rename = "playerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub player_id: crate::media::types::PlayerId,
#[serde(rename = "messages")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub messages: Vec<crate::media::types::PlayerMessage>,
}
impl<'de> serde::Deserialize<'de> for PlayerMessagesLoggedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PlayerMessagesLoggedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "playerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub player_id: crate::media::types::PlayerId,
#[serde(rename = "messages")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub messages: Vec<crate::media::types::PlayerMessage>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PlayerMessagesLoggedParams {
player_id: fields.player_id,
messages: fields.messages,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct PlayerMessagesLogged;
impl ydp_core::Event for PlayerMessagesLogged {
type Params = PlayerMessagesLoggedParams;
const METHOD: &'static str = "Media.playerMessagesLogged";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct PlayerPropertiesChangedParams {
#[serde(rename = "playerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub player_id: crate::media::types::PlayerId,
#[serde(rename = "properties")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub properties: Vec<crate::media::types::PlayerProperty>,
}
impl<'de> serde::Deserialize<'de> for PlayerPropertiesChangedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PlayerPropertiesChangedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "playerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub player_id: crate::media::types::PlayerId,
#[serde(rename = "properties")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub properties: Vec<crate::media::types::PlayerProperty>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PlayerPropertiesChangedParams {
player_id: fields.player_id,
properties: fields.properties,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct PlayerPropertiesChanged;
impl ydp_core::Event for PlayerPropertiesChanged {
type Params = PlayerPropertiesChangedParams;
const METHOD: &'static str = "Media.playerPropertiesChanged";
}