1use serde::{Serialize, Deserialize};
4use crate::browser::types::UserContext;
5use crate::script::types::NodeRemoteValue;
6use crate::script::types::SerializationOptions;
7use crate::script::types::SharedReference;
8use crate::EmptyResult;
9use serde_valid::Validate;
10use super::types::*;
11
12#[derive(Debug, Clone, Serialize, Deserialize)]
13#[serde(untagged)]
14pub enum BrowsingContextCommand {
15 Activate(Activate),
16 CaptureScreenshot(CaptureScreenshot),
17 Close(Close),
18 Create(Create),
19 GetTree(GetTree),
20 HandleUserPrompt(HandleUserPrompt),
21 LocateNodes(LocateNodes),
22 Navigate(Navigate),
23 Print(Print),
24 Reload(Reload),
25 SetViewport(SetViewport),
26 TraverseHistory(TraverseHistory),
27}
28
29
30#[derive(Debug, Clone, Serialize, Deserialize)]
31pub enum BrowsingContextActivateMethod {
32 #[serde(rename = "browsingContext.activate")]
33 BrowsingContextActivate,
34}
35
36#[derive(Debug, Clone, Serialize, Deserialize)]
37pub enum BrowsingContextCaptureScreenshotMethod {
38 #[serde(rename = "browsingContext.captureScreenshot")]
39 BrowsingContextCaptureScreenshot,
40}
41
42#[derive(Debug, Clone, Serialize, Deserialize)]
43pub enum BrowsingContextCloseMethod {
44 #[serde(rename = "browsingContext.close")]
45 BrowsingContextClose,
46}
47
48#[derive(Debug, Clone, Serialize, Deserialize)]
49pub enum BrowsingContextCreateMethod {
50 #[serde(rename = "browsingContext.create")]
51 BrowsingContextCreate,
52}
53
54#[derive(Debug, Clone, Serialize, Deserialize)]
55pub enum BrowsingContextGetTreeMethod {
56 #[serde(rename = "browsingContext.getTree")]
57 BrowsingContextGetTree,
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize)]
61pub enum BrowsingContextHandleUserPromptMethod {
62 #[serde(rename = "browsingContext.handleUserPrompt")]
63 BrowsingContextHandleUserPrompt,
64}
65
66#[derive(Debug, Clone, Serialize, Deserialize)]
67pub enum BrowsingContextLocateNodesMethod {
68 #[serde(rename = "browsingContext.locateNodes")]
69 BrowsingContextLocateNodes,
70}
71
72#[derive(Debug, Clone, Serialize, Deserialize)]
73pub enum BrowsingContextNavigateMethod {
74 #[serde(rename = "browsingContext.navigate")]
75 BrowsingContextNavigate,
76}
77
78#[derive(Debug, Clone, Serialize, Deserialize)]
79pub enum BrowsingContextPrintMethod {
80 #[serde(rename = "browsingContext.print")]
81 BrowsingContextPrint,
82}
83
84#[derive(Debug, Clone, Serialize, Deserialize)]
85pub enum BrowsingContextReloadMethod {
86 #[serde(rename = "browsingContext.reload")]
87 BrowsingContextReload,
88}
89
90#[derive(Debug, Clone, Serialize, Deserialize)]
91pub enum BrowsingContextSetViewportMethod {
92 #[serde(rename = "browsingContext.setViewport")]
93 BrowsingContextSetViewport,
94}
95
96#[derive(Debug, Clone, Serialize, Deserialize)]
97pub enum BrowsingContextTraverseHistoryMethod {
98 #[serde(rename = "browsingContext.traverseHistory")]
99 BrowsingContextTraverseHistory,
100}
101
102#[derive(Debug, Clone, Serialize, Deserialize)]
103pub struct ActivateParameters {
104 #[serde(rename = "context")]
105 pub context: BrowsingContext,
106}
107
108#[derive(Debug, Clone, Serialize, Deserialize)]
109pub struct CaptureScreenshotParameters {
110 #[serde(rename = "context")]
111 pub context: BrowsingContext,
112 #[serde(rename = "origin")]
113 #[serde(skip_serializing_if = "Option::is_none")]
114 pub origin: Option<OriginUnion>,
115 #[serde(rename = "format")]
116 #[serde(skip_serializing_if = "Option::is_none")]
117 pub format: Option<ImageFormat>,
118 #[serde(rename = "clip")]
119 #[serde(skip_serializing_if = "Option::is_none")]
120 pub clip: Option<ClipRectangle>,
121}
122
123#[derive(Debug, Clone, Serialize, Deserialize)]
124pub struct CloseParameters {
125 #[serde(rename = "context")]
126 pub context: BrowsingContext,
127 #[serde(rename = "promptUnload")]
128 #[serde(skip_serializing_if = "Option::is_none")]
129 pub prompt_unload: Option<bool>,
130}
131
132#[derive(Debug, Clone, Serialize, Deserialize)]
133pub struct CreateParameters {
134 #[serde(rename = "type")]
135 pub r#type: CreateType,
136 #[serde(rename = "referenceContext")]
137 #[serde(skip_serializing_if = "Option::is_none")]
138 pub reference_context: Option<BrowsingContext>,
139 #[serde(rename = "background")]
140 #[serde(skip_serializing_if = "Option::is_none")]
141 pub background: Option<bool>,
142 #[serde(rename = "userContext")]
143 #[serde(skip_serializing_if = "Option::is_none")]
144 pub user_context: Option<UserContext>,
145}
146
147#[derive(Debug, Clone, Serialize, Deserialize)]
148pub struct GetTreeParameters {
149 #[serde(rename = "maxDepth")]
150 #[serde(skip_serializing_if = "Option::is_none")]
151 pub max_depth: Option<u64>,
152 #[serde(rename = "root")]
153 #[serde(skip_serializing_if = "Option::is_none")]
154 pub root: Option<BrowsingContext>,
155}
156
157#[derive(Debug, Clone, Serialize, Deserialize)]
158pub struct HandleUserPromptParameters {
159 #[serde(rename = "context")]
160 pub context: BrowsingContext,
161 #[serde(rename = "accept")]
162 #[serde(skip_serializing_if = "Option::is_none")]
163 pub accept: Option<bool>,
164 #[serde(rename = "userText")]
165 #[serde(skip_serializing_if = "Option::is_none")]
166 pub user_text: Option<String>,
167}
168
169#[derive(Debug, Clone, Serialize, Deserialize, Validate)]
170pub struct LocateNodesParameters {
171 #[serde(rename = "context")]
172 pub context: BrowsingContext,
173 #[serde(rename = "locator")]
174 pub locator: Locator,
175 #[serde(rename = "maxNodeCount")]
176 #[serde(skip_serializing_if = "Option::is_none")]
177 #[validate(minimum = 1)]
178 pub max_node_count: Option<u64>,
179 #[serde(rename = "serializationOptions")]
180 #[serde(skip_serializing_if = "Option::is_none")]
181 pub serialization_options: Option<SerializationOptions>,
182 #[serde(rename = "startNodes")]
183 #[serde(skip_serializing_if = "Option::is_none")]
184 pub start_nodes: Option<Vec<SharedReference>>,
185}
186
187#[derive(Debug, Clone, Serialize, Deserialize)]
188pub struct NavigateParameters {
189 #[serde(rename = "context")]
190 pub context: BrowsingContext,
191 #[serde(rename = "url")]
192 pub url: String,
193 #[serde(rename = "wait")]
194 #[serde(skip_serializing_if = "Option::is_none")]
195 pub wait: Option<ReadinessState>,
196}
197
198#[derive(Debug, Clone, Serialize, Deserialize, Validate)]
199pub struct PrintParameters {
200 #[serde(rename = "context")]
201 pub context: BrowsingContext,
202 #[serde(rename = "background")]
203 #[serde(skip_serializing_if = "Option::is_none")]
204 pub background: Option<bool>,
205 #[serde(rename = "margin")]
206 #[serde(skip_serializing_if = "Option::is_none")]
207 pub margin: Option<PrintMarginParameters>,
208 #[serde(rename = "orientation")]
209 #[serde(skip_serializing_if = "Option::is_none")]
210 pub orientation: Option<OrientationUnion>,
211 #[serde(rename = "page")]
212 #[serde(skip_serializing_if = "Option::is_none")]
213 pub page: Option<PrintPageParameters>,
214 #[serde(rename = "pageRanges")]
215 #[serde(skip_serializing_if = "Option::is_none")]
216 pub page_ranges: Option<Vec<PageRangesUnion>>,
217 #[serde(rename = "scale")]
218 #[serde(skip_serializing_if = "Option::is_none")]
219 #[validate(minimum = 0.1)]
220 #[validate(maximum = 2.0)]
221 pub scale: Option<f64>,
222 #[serde(rename = "shrinkToFit")]
223 #[serde(skip_serializing_if = "Option::is_none")]
224 pub shrink_to_fit: Option<bool>,
225}
226
227#[derive(Debug, Clone, Serialize, Deserialize)]
228pub struct ReloadParameters {
229 #[serde(rename = "context")]
230 pub context: BrowsingContext,
231 #[serde(rename = "ignoreCache")]
232 #[serde(skip_serializing_if = "Option::is_none")]
233 pub ignore_cache: Option<bool>,
234 #[serde(rename = "wait")]
235 #[serde(skip_serializing_if = "Option::is_none")]
236 pub wait: Option<ReadinessState>,
237}
238
239#[derive(Debug, Clone, Serialize, Deserialize, Validate)]
240pub struct SetViewportParameters {
241 #[serde(rename = "context")]
242 #[serde(skip_serializing_if = "Option::is_none")]
243 pub context: Option<BrowsingContext>,
244 #[serde(rename = "viewport")]
245 #[serde(skip_serializing_if = "Option::is_none")]
246 pub viewport: Option<Option<Viewport>>,
247 #[serde(rename = "devicePixelRatio")]
248 #[serde(skip_serializing_if = "Option::is_none")]
249 #[validate(minimum = 0.0000000000000002220446049250313)]
250 pub device_pixel_ratio: Option<Option<f64>>,
251 #[serde(rename = "userContexts")]
252 #[serde(skip_serializing_if = "Option::is_none")]
253 pub user_contexts: Option<Vec<UserContext>>,
254}
255
256#[derive(Debug, Clone, Serialize, Deserialize)]
257pub struct TraverseHistoryParameters {
258 #[serde(rename = "context")]
259 pub context: BrowsingContext,
260 #[serde(rename = "delta")]
261 pub delta: i64,
262}
263
264#[derive(Debug, Clone, Serialize, Deserialize)]
265pub struct Activate {
266 #[serde(rename = "method")]
267 pub method: BrowsingContextActivateMethod,
268 #[serde(rename = "params")]
269 pub params: ActivateParameters,
270}
271
272#[derive(Debug, Clone, Serialize, Deserialize)]
273pub struct CaptureScreenshot {
274 #[serde(rename = "method")]
275 pub method: BrowsingContextCaptureScreenshotMethod,
276 #[serde(rename = "params")]
277 pub params: CaptureScreenshotParameters,
278}
279
280#[derive(Debug, Clone, Serialize, Deserialize)]
281pub struct Close {
282 #[serde(rename = "method")]
283 pub method: BrowsingContextCloseMethod,
284 #[serde(rename = "params")]
285 pub params: CloseParameters,
286}
287
288#[derive(Debug, Clone, Serialize, Deserialize)]
289pub struct Create {
290 #[serde(rename = "method")]
291 pub method: BrowsingContextCreateMethod,
292 #[serde(rename = "params")]
293 pub params: CreateParameters,
294}
295
296#[derive(Debug, Clone, Serialize, Deserialize)]
297pub struct GetTree {
298 #[serde(rename = "method")]
299 pub method: BrowsingContextGetTreeMethod,
300 #[serde(rename = "params")]
301 pub params: GetTreeParameters,
302}
303
304#[derive(Debug, Clone, Serialize, Deserialize)]
305pub struct HandleUserPrompt {
306 #[serde(rename = "method")]
307 pub method: BrowsingContextHandleUserPromptMethod,
308 #[serde(rename = "params")]
309 pub params: HandleUserPromptParameters,
310}
311
312#[derive(Debug, Clone, Serialize, Deserialize)]
313pub struct LocateNodes {
314 #[serde(rename = "method")]
315 pub method: BrowsingContextLocateNodesMethod,
316 #[serde(rename = "params")]
317 pub params: LocateNodesParameters,
318}
319
320#[derive(Debug, Clone, Serialize, Deserialize)]
321pub struct Navigate {
322 #[serde(rename = "method")]
323 pub method: BrowsingContextNavigateMethod,
324 #[serde(rename = "params")]
325 pub params: NavigateParameters,
326}
327
328#[derive(Debug, Clone, Serialize, Deserialize)]
329pub struct Print {
330 #[serde(rename = "method")]
331 pub method: BrowsingContextPrintMethod,
332 #[serde(rename = "params")]
333 pub params: PrintParameters,
334}
335
336#[derive(Debug, Clone, Serialize, Deserialize)]
337pub struct Reload {
338 #[serde(rename = "method")]
339 pub method: BrowsingContextReloadMethod,
340 #[serde(rename = "params")]
341 pub params: ReloadParameters,
342}
343
344#[derive(Debug, Clone, Serialize, Deserialize)]
345pub struct SetViewport {
346 #[serde(rename = "method")]
347 pub method: BrowsingContextSetViewportMethod,
348 #[serde(rename = "params")]
349 pub params: SetViewportParameters,
350}
351
352#[derive(Debug, Clone, Serialize, Deserialize)]
353pub struct TraverseHistory {
354 #[serde(rename = "method")]
355 pub method: BrowsingContextTraverseHistoryMethod,
356 #[serde(rename = "params")]
357 pub params: TraverseHistoryParameters,
358}
359
360#[derive(Debug, Clone, Serialize, Deserialize)]
363#[serde(untagged)]
364pub enum BrowsingContextResult {
365 ActivateResult(ActivateResult),
366 CaptureScreenshotResult(CaptureScreenshotResult),
367 CloseResult(CloseResult),
368 CreateResult(CreateResult),
369 GetTreeResult(GetTreeResult),
370 HandleUserPromptResult(HandleUserPromptResult),
371 LocateNodesResult(LocateNodesResult),
372 NavigateResult(NavigateResult),
373 PrintResult(PrintResult),
374 ReloadResult(ReloadResult),
375 SetViewportResult(SetViewportResult),
376 TraverseHistoryResult(TraverseHistoryResult),
377}
378
379
380pub type ActivateResult = EmptyResult;
381
382
383#[derive(Debug, Clone, Serialize, Deserialize)]
384pub struct CaptureScreenshotResult {
385 #[serde(rename = "data")]
386 pub data: String,
387}
388
389pub type CloseResult = EmptyResult;
390
391
392#[derive(Debug, Clone, Serialize, Deserialize)]
393pub struct CreateResult {
394 #[serde(rename = "context")]
395 pub context: BrowsingContext,
396}
397
398#[derive(Debug, Clone, Serialize, Deserialize)]
399pub struct GetTreeResult {
400 #[serde(rename = "contexts")]
401 pub contexts: InfoList,
402}
403
404pub type HandleUserPromptResult = EmptyResult;
405
406
407#[derive(Debug, Clone, Serialize, Deserialize)]
408pub struct LocateNodesResult {
409 #[serde(rename = "nodes")]
410 pub nodes: Vec<NodeRemoteValue>,
411}
412
413#[derive(Debug, Clone, Serialize, Deserialize)]
414pub struct NavigateResult {
415 #[serde(rename = "navigation")]
416 pub navigation: Option<Navigation>,
417 #[serde(rename = "url")]
418 pub url: String,
419}
420
421#[derive(Debug, Clone, Serialize, Deserialize)]
422pub struct PrintResult {
423 #[serde(rename = "data")]
424 pub data: String,
425}
426
427pub type ReloadResult = NavigateResult;
428
429
430pub type SetViewportResult = EmptyResult;
431
432
433pub type TraverseHistoryResult = EmptyResult;
434
435