cdp_protocol/
animation.rs

1// Auto-generated from Chrome at version 143.0.7499.110 domain: Animation
2use super::dom;
3use super::runtime;
4#[allow(unused_imports)]
5use super::types::*;
6#[allow(unused_imports)]
7use serde::{Deserialize, Serialize};
8#[allow(unused_imports)]
9use serde_json::Value as Json;
10#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
11pub enum AnimationType {
12    #[serde(rename = "CSSTransition")]
13    CssTransition,
14    #[serde(rename = "CSSAnimation")]
15    CssAnimation,
16    #[serde(rename = "WebAnimation")]
17    WebAnimation,
18}
19#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
20pub struct Animation {
21    #[serde(default)]
22    #[serde(rename = "id")]
23    pub id: String,
24    #[serde(default)]
25    #[serde(rename = "name")]
26    pub name: String,
27    #[serde(default)]
28    #[serde(rename = "pausedState")]
29    pub paused_state: bool,
30    #[serde(default)]
31    #[serde(rename = "playState")]
32    pub play_state: String,
33    #[serde(default)]
34    #[serde(rename = "playbackRate")]
35    pub playback_rate: JsFloat,
36    #[serde(default)]
37    #[serde(rename = "startTime")]
38    pub start_time: JsFloat,
39    #[serde(default)]
40    #[serde(rename = "currentTime")]
41    pub current_time: JsFloat,
42    #[serde(rename = "type")]
43    pub r#type: AnimationType,
44    #[serde(skip_serializing_if = "Option::is_none")]
45    #[serde(rename = "source")]
46    pub source: Option<AnimationEffect>,
47    #[serde(skip_serializing_if = "Option::is_none")]
48    #[serde(default)]
49    #[serde(rename = "cssId")]
50    pub css_id: Option<String>,
51    #[serde(skip_serializing_if = "Option::is_none")]
52    #[serde(rename = "viewOrScrollTimeline")]
53    pub view_or_scroll_timeline: Option<ViewOrScrollTimeline>,
54}
55#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
56pub struct ViewOrScrollTimeline {
57    #[serde(skip_serializing_if = "Option::is_none")]
58    #[serde(rename = "sourceNodeId")]
59    pub source_node_id: Option<dom::BackendNodeId>,
60    #[serde(skip_serializing_if = "Option::is_none")]
61    #[serde(default)]
62    #[serde(rename = "startOffset")]
63    pub start_offset: Option<JsFloat>,
64    #[serde(skip_serializing_if = "Option::is_none")]
65    #[serde(default)]
66    #[serde(rename = "endOffset")]
67    pub end_offset: Option<JsFloat>,
68    #[serde(skip_serializing_if = "Option::is_none")]
69    #[serde(rename = "subjectNodeId")]
70    pub subject_node_id: Option<dom::BackendNodeId>,
71    #[serde(rename = "axis")]
72    pub axis: dom::ScrollOrientation,
73}
74#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
75pub struct AnimationEffect {
76    #[serde(default)]
77    #[serde(rename = "delay")]
78    pub delay: JsFloat,
79    #[serde(default)]
80    #[serde(rename = "endDelay")]
81    pub end_delay: JsFloat,
82    #[serde(default)]
83    #[serde(rename = "iterationStart")]
84    pub iteration_start: JsFloat,
85    #[serde(default)]
86    #[serde(rename = "iterations")]
87    pub iterations: JsFloat,
88    #[serde(default)]
89    #[serde(rename = "duration")]
90    pub duration: JsFloat,
91    #[serde(default)]
92    #[serde(rename = "direction")]
93    pub direction: String,
94    #[serde(default)]
95    #[serde(rename = "fill")]
96    pub fill: String,
97    #[serde(skip_serializing_if = "Option::is_none")]
98    #[serde(rename = "backendNodeId")]
99    pub backend_node_id: Option<dom::BackendNodeId>,
100    #[serde(skip_serializing_if = "Option::is_none")]
101    #[serde(rename = "keyframesRule")]
102    pub keyframes_rule: Option<KeyframesRule>,
103    #[serde(default)]
104    #[serde(rename = "easing")]
105    pub easing: String,
106}
107#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
108pub struct KeyframesRule {
109    #[serde(skip_serializing_if = "Option::is_none")]
110    #[serde(default)]
111    #[serde(rename = "name")]
112    pub name: Option<String>,
113    #[serde(rename = "keyframes")]
114    pub keyframes: Vec<KeyframeStyle>,
115}
116#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
117pub struct KeyframeStyle {
118    #[serde(default)]
119    #[serde(rename = "offset")]
120    pub offset: String,
121    #[serde(default)]
122    #[serde(rename = "easing")]
123    pub easing: String,
124}
125#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
126#[serde(rename_all = "camelCase")]
127pub struct Disable(pub Option<serde_json::Value>);
128#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
129#[serde(rename_all = "camelCase")]
130pub struct Enable(pub Option<serde_json::Value>);
131#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
132pub struct GetCurrentTime {
133    #[serde(default)]
134    #[serde(rename = "id")]
135    pub id: String,
136}
137#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
138#[serde(rename_all = "camelCase")]
139pub struct GetPlaybackRate(pub Option<serde_json::Value>);
140#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
141pub struct ReleaseAnimations {
142    #[serde(default)]
143    #[serde(rename = "animations")]
144    pub animations: Vec<String>,
145}
146#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
147pub struct ResolveAnimation {
148    #[serde(default)]
149    #[serde(rename = "animationId")]
150    pub animation_id: String,
151}
152#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
153pub struct SeekAnimations {
154    #[serde(default)]
155    #[serde(rename = "animations")]
156    pub animations: Vec<String>,
157    #[serde(default)]
158    #[serde(rename = "currentTime")]
159    pub current_time: JsFloat,
160}
161#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
162pub struct SetPaused {
163    #[serde(default)]
164    #[serde(rename = "animations")]
165    pub animations: Vec<String>,
166    #[serde(default)]
167    #[serde(rename = "paused")]
168    pub paused: bool,
169}
170#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
171pub struct SetPlaybackRate {
172    #[serde(default)]
173    #[serde(rename = "playbackRate")]
174    pub playback_rate: JsFloat,
175}
176#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
177pub struct SetTiming {
178    #[serde(default)]
179    #[serde(rename = "animationId")]
180    pub animation_id: String,
181    #[serde(default)]
182    #[serde(rename = "duration")]
183    pub duration: JsFloat,
184    #[serde(default)]
185    #[serde(rename = "delay")]
186    pub delay: JsFloat,
187}
188#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
189#[serde(rename_all = "camelCase")]
190pub struct DisableReturnObject {}
191#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
192#[serde(rename_all = "camelCase")]
193pub struct EnableReturnObject {}
194#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
195pub struct GetCurrentTimeReturnObject {
196    #[serde(default)]
197    #[serde(rename = "currentTime")]
198    pub current_time: JsFloat,
199}
200#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
201pub struct GetPlaybackRateReturnObject {
202    #[serde(default)]
203    #[serde(rename = "playbackRate")]
204    pub playback_rate: JsFloat,
205}
206#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
207#[serde(rename_all = "camelCase")]
208pub struct ReleaseAnimationsReturnObject {}
209#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
210pub struct ResolveAnimationReturnObject {
211    #[serde(rename = "remoteObject")]
212    pub remote_object: runtime::RemoteObject,
213}
214#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
215#[serde(rename_all = "camelCase")]
216pub struct SeekAnimationsReturnObject {}
217#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
218#[serde(rename_all = "camelCase")]
219pub struct SetPausedReturnObject {}
220#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
221#[serde(rename_all = "camelCase")]
222pub struct SetPlaybackRateReturnObject {}
223#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
224#[serde(rename_all = "camelCase")]
225pub struct SetTimingReturnObject {}
226impl Method for Disable {
227    const NAME: &'static str = "Animation.disable";
228    type ReturnObject = DisableReturnObject;
229}
230impl Method for Enable {
231    const NAME: &'static str = "Animation.enable";
232    type ReturnObject = EnableReturnObject;
233}
234impl Method for GetCurrentTime {
235    const NAME: &'static str = "Animation.getCurrentTime";
236    type ReturnObject = GetCurrentTimeReturnObject;
237}
238impl Method for GetPlaybackRate {
239    const NAME: &'static str = "Animation.getPlaybackRate";
240    type ReturnObject = GetPlaybackRateReturnObject;
241}
242impl Method for ReleaseAnimations {
243    const NAME: &'static str = "Animation.releaseAnimations";
244    type ReturnObject = ReleaseAnimationsReturnObject;
245}
246impl Method for ResolveAnimation {
247    const NAME: &'static str = "Animation.resolveAnimation";
248    type ReturnObject = ResolveAnimationReturnObject;
249}
250impl Method for SeekAnimations {
251    const NAME: &'static str = "Animation.seekAnimations";
252    type ReturnObject = SeekAnimationsReturnObject;
253}
254impl Method for SetPaused {
255    const NAME: &'static str = "Animation.setPaused";
256    type ReturnObject = SetPausedReturnObject;
257}
258impl Method for SetPlaybackRate {
259    const NAME: &'static str = "Animation.setPlaybackRate";
260    type ReturnObject = SetPlaybackRateReturnObject;
261}
262impl Method for SetTiming {
263    const NAME: &'static str = "Animation.setTiming";
264    type ReturnObject = SetTimingReturnObject;
265}
266pub mod events {
267    #[allow(unused_imports)]
268    use super::super::types::*;
269    #[allow(unused_imports)]
270    use serde::{Deserialize, Serialize};
271    #[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
272    pub struct AnimationCanceledEvent {
273        pub params: AnimationCanceledEventParams,
274    }
275    #[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
276    pub struct AnimationCanceledEventParams {
277        #[serde(default)]
278        #[serde(rename = "id")]
279        pub id: String,
280    }
281    #[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
282    pub struct AnimationCreatedEvent {
283        pub params: AnimationCreatedEventParams,
284    }
285    #[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
286    pub struct AnimationCreatedEventParams {
287        #[serde(default)]
288        #[serde(rename = "id")]
289        pub id: String,
290    }
291    #[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
292    pub struct AnimationStartedEvent {
293        pub params: AnimationStartedEventParams,
294    }
295    #[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
296    pub struct AnimationStartedEventParams {
297        #[serde(rename = "animation")]
298        pub animation: super::Animation,
299    }
300    #[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
301    pub struct AnimationUpdatedEvent {
302        pub params: AnimationUpdatedEventParams,
303    }
304    #[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
305    pub struct AnimationUpdatedEventParams {
306        #[serde(rename = "animation")]
307        pub animation: super::Animation,
308    }
309}