#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct DisableParams {}
impl<'de> serde::Deserialize<'de> for DisableParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DisableParams;
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 {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DisableParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Disable;
#[derive(Debug, Clone, serde::Serialize)]
pub struct DisableResponse {}
impl<'de> serde::Deserialize<'de> for DisableResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DisableResponse;
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 {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DisableResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Disable {
type Params = DisableParams;
type Response = DisableResponse;
const METHOD: &'static str = "Animation.disable";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct EnableParams {}
impl<'de> serde::Deserialize<'de> for EnableParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = EnableParams;
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 {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(EnableParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Enable;
#[derive(Debug, Clone, serde::Serialize)]
pub struct EnableResponse {}
impl<'de> serde::Deserialize<'de> for EnableResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = EnableResponse;
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 {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(EnableResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Enable {
type Params = EnableParams;
type Response = EnableResponse;
const METHOD: &'static str = "Animation.enable";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetCurrentTimeParams {
#[serde(rename = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
}
impl<'de> serde::Deserialize<'de> for GetCurrentTimeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetCurrentTimeParams;
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 = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetCurrentTimeParams { id: fields.id })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetCurrentTime;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetCurrentTimeResponse {
#[serde(rename = "currentTime")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub current_time: ydp_core::FiniteF64,
}
impl<'de> serde::Deserialize<'de> for GetCurrentTimeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetCurrentTimeResponse;
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 = "currentTime")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub current_time: ydp_core::FiniteF64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetCurrentTimeResponse {
current_time: fields.current_time,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetCurrentTime {
type Params = GetCurrentTimeParams;
type Response = GetCurrentTimeResponse;
const METHOD: &'static str = "Animation.getCurrentTime";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetPlaybackRateParams {}
impl<'de> serde::Deserialize<'de> for GetPlaybackRateParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetPlaybackRateParams;
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 {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetPlaybackRateParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetPlaybackRate;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetPlaybackRateResponse {
#[serde(rename = "playbackRate")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub playback_rate: ydp_core::FiniteF64,
}
impl<'de> serde::Deserialize<'de> for GetPlaybackRateResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetPlaybackRateResponse;
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 = "playbackRate")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub playback_rate: ydp_core::FiniteF64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetPlaybackRateResponse {
playback_rate: fields.playback_rate,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetPlaybackRate {
type Params = GetPlaybackRateParams;
type Response = GetPlaybackRateResponse;
const METHOD: &'static str = "Animation.getPlaybackRate";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ReleaseAnimationsParams {
#[serde(rename = "animations")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub animations: Vec<String>,
}
impl<'de> serde::Deserialize<'de> for ReleaseAnimationsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ReleaseAnimationsParams;
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 = "animations")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub animations: Vec<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ReleaseAnimationsParams {
animations: fields.animations,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ReleaseAnimations;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ReleaseAnimationsResponse {}
impl<'de> serde::Deserialize<'de> for ReleaseAnimationsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ReleaseAnimationsResponse;
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 {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ReleaseAnimationsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ReleaseAnimations {
type Params = ReleaseAnimationsParams;
type Response = ReleaseAnimationsResponse;
const METHOD: &'static str = "Animation.releaseAnimations";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ResolveAnimationParams {
#[serde(rename = "animationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub animation_id: String,
}
impl<'de> serde::Deserialize<'de> for ResolveAnimationParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResolveAnimationParams;
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 = "animationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub animation_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ResolveAnimationParams {
animation_id: fields.animation_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ResolveAnimation;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ResolveAnimationResponse {
#[serde(rename = "remoteObject")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub remote_object: crate::runtime::types::RemoteObject,
}
impl<'de> serde::Deserialize<'de> for ResolveAnimationResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResolveAnimationResponse;
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 = "remoteObject")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub remote_object: crate::runtime::types::RemoteObject,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ResolveAnimationResponse {
remote_object: fields.remote_object,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ResolveAnimation {
type Params = ResolveAnimationParams;
type Response = ResolveAnimationResponse;
const METHOD: &'static str = "Animation.resolveAnimation";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SeekAnimationsParams {
#[serde(rename = "animations")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub animations: Vec<String>,
#[serde(rename = "currentTime")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub current_time: ydp_core::FiniteF64,
}
impl<'de> serde::Deserialize<'de> for SeekAnimationsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SeekAnimationsParams;
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 = "animations")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub animations: Vec<String>,
#[serde(rename = "currentTime")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub current_time: ydp_core::FiniteF64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SeekAnimationsParams {
animations: fields.animations,
current_time: fields.current_time,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SeekAnimations;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SeekAnimationsResponse {}
impl<'de> serde::Deserialize<'de> for SeekAnimationsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SeekAnimationsResponse;
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 {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SeekAnimationsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SeekAnimations {
type Params = SeekAnimationsParams;
type Response = SeekAnimationsResponse;
const METHOD: &'static str = "Animation.seekAnimations";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPausedParams {
#[serde(rename = "animations")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub animations: Vec<String>,
#[serde(rename = "paused")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub paused: bool,
}
impl<'de> serde::Deserialize<'de> for SetPausedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPausedParams;
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 = "animations")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub animations: Vec<String>,
#[serde(rename = "paused")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub paused: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetPausedParams {
animations: fields.animations,
paused: fields.paused,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetPaused;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPausedResponse {}
impl<'de> serde::Deserialize<'de> for SetPausedResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPausedResponse;
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 {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetPausedResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetPaused {
type Params = SetPausedParams;
type Response = SetPausedResponse;
const METHOD: &'static str = "Animation.setPaused";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPlaybackRateParams {
#[serde(rename = "playbackRate")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub playback_rate: ydp_core::FiniteF64,
}
impl<'de> serde::Deserialize<'de> for SetPlaybackRateParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPlaybackRateParams;
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 = "playbackRate")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub playback_rate: ydp_core::FiniteF64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetPlaybackRateParams {
playback_rate: fields.playback_rate,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetPlaybackRate;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPlaybackRateResponse {}
impl<'de> serde::Deserialize<'de> for SetPlaybackRateResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPlaybackRateResponse;
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 {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetPlaybackRateResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetPlaybackRate {
type Params = SetPlaybackRateParams;
type Response = SetPlaybackRateResponse;
const METHOD: &'static str = "Animation.setPlaybackRate";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetTimingParams {
#[serde(rename = "animationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub animation_id: String,
#[serde(rename = "duration")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub duration: ydp_core::FiniteF64,
#[serde(rename = "delay")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub delay: ydp_core::FiniteF64,
}
impl<'de> serde::Deserialize<'de> for SetTimingParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetTimingParams;
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 = "animationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub animation_id: String,
#[serde(rename = "duration")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub duration: ydp_core::FiniteF64,
#[serde(rename = "delay")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub delay: ydp_core::FiniteF64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetTimingParams {
animation_id: fields.animation_id,
duration: fields.duration,
delay: fields.delay,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetTiming;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetTimingResponse {}
impl<'de> serde::Deserialize<'de> for SetTimingResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetTimingResponse;
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 {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetTimingResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetTiming {
type Params = SetTimingParams;
type Response = SetTimingResponse;
const METHOD: &'static str = "Animation.setTiming";
}