1use serde::{Serialize, Deserialize};
3use crate::browsing_context::types::BrowsingContext;
4use crate::Extensible;
5
6#[derive(Debug, Clone, Serialize, Deserialize)]
7pub enum ChannelEnum {
8 #[serde(rename = "channel")]
9 Channel,
10}
11
12pub type Channel = String;
13
14
15#[derive(Debug, Clone, Serialize, Deserialize)]
16pub enum SerializationOptionsincludeShadowTreeUnion {
17 #[serde(rename = "none")]
18 None,
19 #[serde(rename = "open")]
20 Open,
21 #[serde(rename = "all")]
22 All,
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
26pub struct SerializationOptions {
27 #[serde(rename = "maxDomDepth")]
28 #[serde(skip_serializing_if = "Option::is_none")]
29 pub max_dom_depth: Option<Option<u64>>,
30 #[serde(rename = "maxObjectDepth")]
31 #[serde(skip_serializing_if = "Option::is_none")]
32 pub max_object_depth: Option<Option<u64>>,
33 #[serde(rename = "includeShadowTree")]
34 #[serde(skip_serializing_if = "Option::is_none")]
35 pub include_shadow_tree: Option<SerializationOptionsincludeShadowTreeUnion>,
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize)]
39pub enum ResultOwnership {
40 #[serde(rename = "root")]
41 Root,
42 #[serde(rename = "none")]
43 None,
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
47pub struct ChannelProperties {
48 #[serde(rename = "channel")]
49 pub channel: Channel,
50 #[serde(rename = "serializationOptions")]
51 #[serde(skip_serializing_if = "Option::is_none")]
52 pub serialization_options: Option<SerializationOptions>,
53 #[serde(rename = "ownership")]
54 #[serde(skip_serializing_if = "Option::is_none")]
55 pub ownership: Option<ResultOwnership>,
56}
57
58#[derive(Debug, Clone, Serialize, Deserialize)]
59pub struct ChannelValue {
60 #[serde(rename = "type")]
61 pub r#type: ChannelEnum,
62 #[serde(rename = "value")]
63 pub value: ChannelProperties,
64}
65
66#[derive(Debug, Clone, Serialize, Deserialize)]
67pub struct ContextTarget {
68 #[serde(rename = "context")]
69 pub context: BrowsingContext,
70 #[serde(rename = "sandbox")]
71 #[serde(skip_serializing_if = "Option::is_none")]
72 pub sandbox: Option<String>,
73}
74
75pub type Realm = String;
76
77
78#[derive(Debug, Clone, Serialize, Deserialize)]
79pub struct RealmTarget {
80 #[serde(rename = "realm")]
81 pub realm: Realm,
82}
83
84#[derive(Debug, Clone, Serialize, Deserialize)]
85#[serde(untagged)]
86pub enum Target {
87 ContextTarget(ContextTarget),
88 RealmTarget(RealmTarget),
89}
90
91pub type SharedId = String;
92
93
94pub type Handle = String;
95
96
97#[derive(Debug, Clone, Serialize, Deserialize)]
98pub struct SharedReference {
99 #[serde(rename = "sharedId")]
100 pub shared_id: SharedId,
101 #[serde(rename = "handle")]
102 #[serde(skip_serializing_if = "Option::is_none")]
103 pub handle: Option<Handle>,
104 #[serde(flatten)]
105 pub extensible: Extensible,
106}
107
108#[derive(Debug, Clone, Serialize, Deserialize)]
109pub struct RemoteObjectReference {
110 #[serde(rename = "handle")]
111 pub handle: Handle,
112 #[serde(rename = "sharedId")]
113 #[serde(skip_serializing_if = "Option::is_none")]
114 pub shared_id: Option<SharedId>,
115 #[serde(flatten)]
116 pub extensible: Extensible,
117}
118
119#[derive(Debug, Clone, Serialize, Deserialize)]
120#[serde(untagged)]
121pub enum RemoteReference {
122 SharedReference(SharedReference),
123 RemoteObjectReference(RemoteObjectReference),
124}
125
126#[derive(Debug, Clone, Serialize, Deserialize)]
127pub enum UndefinedEnum {
128 #[serde(rename = "undefined")]
129 Undefined,
130}
131
132#[derive(Debug, Clone, Serialize, Deserialize)]
133pub struct UndefinedValue {
134 #[serde(rename = "type")]
135 pub r#type: UndefinedEnum,
136}
137
138#[derive(Debug, Clone, Serialize, Deserialize)]
139pub enum NullEnum {
140 #[serde(rename = "null")]
141 Null,
142}
143
144#[derive(Debug, Clone, Serialize, Deserialize)]
145pub struct NullValue {
146 #[serde(rename = "type")]
147 pub r#type: NullEnum,
148}
149
150#[derive(Debug, Clone, Serialize, Deserialize)]
151pub enum StringEnum {
152 #[serde(rename = "string")]
153 String,
154}
155
156#[derive(Debug, Clone, Serialize, Deserialize)]
157pub struct StringValue {
158 #[serde(rename = "type")]
159 pub r#type: StringEnum,
160 #[serde(rename = "value")]
161 pub value: String,
162}
163
164#[derive(Debug, Clone, Serialize, Deserialize)]
165pub enum NumberEnum {
166 #[serde(rename = "number")]
167 Number,
168}
169
170#[derive(Debug, Clone, Serialize, Deserialize)]
171pub enum SpecialNumber {
172 #[serde(rename = "NaN")]
173 NaN,
174 #[serde(rename = "-0")]
175 Negative0,
176 #[serde(rename = "Infinity")]
177 Infinity,
178 #[serde(rename = "-Infinity")]
179 NegativeInfinity,
180}
181
182#[derive(Debug, Clone, Serialize, Deserialize)]
183#[serde(untagged)]
184pub enum NumberValuevalueUnion {
185 Number(serde_json::value::Number),
186 SpecialNumber(SpecialNumber),
187}
188
189#[derive(Debug, Clone, Serialize, Deserialize)]
190pub struct NumberValue {
191 #[serde(rename = "type")]
192 pub r#type: NumberEnum,
193 #[serde(rename = "value")]
194 pub value: NumberValuevalueUnion,
195}
196
197#[derive(Debug, Clone, Serialize, Deserialize)]
198pub enum BooleanEnum {
199 #[serde(rename = "boolean")]
200 Boolean,
201}
202
203#[derive(Debug, Clone, Serialize, Deserialize)]
204pub struct BooleanValue {
205 #[serde(rename = "type")]
206 pub r#type: BooleanEnum,
207 #[serde(rename = "value")]
208 pub value: bool,
209}
210
211#[derive(Debug, Clone, Serialize, Deserialize)]
212pub enum BigintEnum {
213 #[serde(rename = "bigint")]
214 Bigint,
215}
216
217#[derive(Debug, Clone, Serialize, Deserialize)]
218pub struct BigIntValue {
219 #[serde(rename = "type")]
220 pub r#type: BigintEnum,
221 #[serde(rename = "value")]
222 pub value: String,
223}
224
225#[derive(Debug, Clone, Serialize, Deserialize)]
226#[serde(untagged)]
227pub enum PrimitiveProtocolValue {
228 UndefinedValue(UndefinedValue),
229 NullValue(NullValue),
230 StringValue(StringValue),
231 NumberValue(NumberValue),
232 BooleanValue(BooleanValue),
233 BigIntValue(BigIntValue),
234}
235
236#[derive(Debug, Clone, Serialize, Deserialize)]
237pub enum ArrayEnum {
238 #[serde(rename = "array")]
239 Array,
240}
241
242pub type ListLocalValue = Vec<LocalValue>;
243
244
245#[derive(Debug, Clone, Serialize, Deserialize)]
246pub struct ArrayLocalValue {
247 #[serde(rename = "type")]
248 pub r#type: ArrayEnum,
249 #[serde(rename = "value")]
250 pub value: ListLocalValue,
251}
252
253#[derive(Debug, Clone, Serialize, Deserialize)]
254pub enum DateEnum {
255 #[serde(rename = "date")]
256 Date,
257}
258
259#[derive(Debug, Clone, Serialize, Deserialize)]
260pub struct DateLocalValue {
261 #[serde(rename = "type")]
262 pub r#type: DateEnum,
263 #[serde(rename = "value")]
264 pub value: String,
265}
266
267#[derive(Debug, Clone, Serialize, Deserialize)]
268pub enum MapEnum {
269 #[serde(rename = "map")]
270 Map,
271}
272
273#[derive(Debug, Clone, Serialize, Deserialize)]
274#[serde(untagged)]
275pub enum MappingLocalValueMappingLocalValueUnion {
276 LocalValue(LocalValue),
277 String(String),
278}
279
280pub type MappingLocalValue = Vec<(MappingLocalValueMappingLocalValueUnion, LocalValue)>;
281
282
283#[derive(Debug, Clone, Serialize, Deserialize)]
284pub struct MapLocalValue {
285 #[serde(rename = "type")]
286 pub r#type: MapEnum,
287 #[serde(rename = "value")]
288 pub value: MappingLocalValue,
289}
290
291#[derive(Debug, Clone, Serialize, Deserialize)]
292pub enum ObjectEnum {
293 #[serde(rename = "object")]
294 Object,
295}
296
297#[derive(Debug, Clone, Serialize, Deserialize)]
298pub struct ObjectLocalValue {
299 #[serde(rename = "type")]
300 pub r#type: ObjectEnum,
301 #[serde(rename = "value")]
302 pub value: MappingLocalValue,
303}
304
305#[derive(Debug, Clone, Serialize, Deserialize)]
306pub enum RegexpEnum {
307 #[serde(rename = "regexp")]
308 Regexp,
309}
310
311#[derive(Debug, Clone, Serialize, Deserialize)]
312pub struct RegExpValue {
313 #[serde(rename = "pattern")]
314 pub pattern: String,
315 #[serde(rename = "flags")]
316 #[serde(skip_serializing_if = "Option::is_none")]
317 pub flags: Option<String>,
318}
319
320#[derive(Debug, Clone, Serialize, Deserialize)]
321pub struct RegExpLocalValue {
322 #[serde(rename = "type")]
323 pub r#type: RegexpEnum,
324 #[serde(rename = "value")]
325 pub value: RegExpValue,
326}
327
328#[derive(Debug, Clone, Serialize, Deserialize)]
329pub enum SetEnum {
330 #[serde(rename = "set")]
331 Set,
332}
333
334#[derive(Debug, Clone, Serialize, Deserialize)]
335pub struct SetLocalValue {
336 #[serde(rename = "type")]
337 pub r#type: SetEnum,
338 #[serde(rename = "value")]
339 pub value: ListLocalValue,
340}
341
342#[derive(Debug, Clone, Serialize, Deserialize)]
343#[serde(untagged)]
344pub enum LocalValue {
345 RemoteReference(RemoteReference),
346 PrimitiveProtocolValue(PrimitiveProtocolValue),
347 ChannelValue(ChannelValue),
348 ArrayLocalValue(ArrayLocalValue),
349 DateLocalValue(DateLocalValue),
350 MapLocalValue(MapLocalValue),
351 ObjectLocalValue(ObjectLocalValue),
352 RegExpLocalValue(RegExpLocalValue),
353 SetLocalValue(SetLocalValue),
354}
355
356#[derive(Debug, Clone, Serialize, Deserialize)]
357pub enum RealmType {
358 #[serde(rename = "window")]
359 Window,
360 #[serde(rename = "dedicated-worker")]
361 DedicatedWorker,
362 #[serde(rename = "shared-worker")]
363 SharedWorker,
364 #[serde(rename = "service-worker")]
365 ServiceWorker,
366 #[serde(rename = "worker")]
367 Worker,
368 #[serde(rename = "paint-worklet")]
369 PaintWorklet,
370 #[serde(rename = "audio-worklet")]
371 AudioWorklet,
372 #[serde(rename = "worklet")]
373 Worklet,
374}
375
376pub type PreloadScript = String;
377
378
379#[derive(Debug, Clone, Serialize, Deserialize)]
380pub enum SuccessEnum {
381 #[serde(rename = "success")]
382 Success,
383}
384
385#[derive(Debug, Clone, Serialize, Deserialize)]
386pub enum SymbolEnum {
387 #[serde(rename = "symbol")]
388 Symbol,
389}
390
391pub type InternalId = String;
392
393
394#[derive(Debug, Clone, Serialize, Deserialize)]
395pub struct SymbolRemoteValue {
396 #[serde(rename = "type")]
397 pub r#type: SymbolEnum,
398 #[serde(rename = "handle")]
399 #[serde(skip_serializing_if = "Option::is_none")]
400 pub handle: Option<Handle>,
401 #[serde(rename = "internalId")]
402 #[serde(skip_serializing_if = "Option::is_none")]
403 pub internal_id: Option<InternalId>,
404}
405
406pub type ListRemoteValue = Vec<RemoteValue>;
407
408
409#[derive(Debug, Clone, Serialize, Deserialize)]
410pub struct ArrayRemoteValue {
411 #[serde(rename = "type")]
412 pub r#type: ArrayEnum,
413 #[serde(rename = "handle")]
414 #[serde(skip_serializing_if = "Option::is_none")]
415 pub handle: Option<Handle>,
416 #[serde(rename = "internalId")]
417 #[serde(skip_serializing_if = "Option::is_none")]
418 pub internal_id: Option<InternalId>,
419 #[serde(rename = "value")]
420 #[serde(skip_serializing_if = "Option::is_none")]
421 pub value: Option<ListRemoteValue>,
422}
423
424#[derive(Debug, Clone, Serialize, Deserialize)]
425#[serde(untagged)]
426pub enum MappingRemoteValueMappingRemoteValueUnion {
427 RemoteValue(RemoteValue),
428 String(String),
429}
430
431pub type MappingRemoteValue = Vec<(MappingRemoteValueMappingRemoteValueUnion, RemoteValue)>;
432
433
434#[derive(Debug, Clone, Serialize, Deserialize)]
435pub struct ObjectRemoteValue {
436 #[serde(rename = "type")]
437 pub r#type: ObjectEnum,
438 #[serde(rename = "handle")]
439 #[serde(skip_serializing_if = "Option::is_none")]
440 pub handle: Option<Handle>,
441 #[serde(rename = "internalId")]
442 #[serde(skip_serializing_if = "Option::is_none")]
443 pub internal_id: Option<InternalId>,
444 #[serde(rename = "value")]
445 #[serde(skip_serializing_if = "Option::is_none")]
446 pub value: Option<MappingRemoteValue>,
447}
448
449#[derive(Debug, Clone, Serialize, Deserialize)]
450pub enum FunctionEnum {
451 #[serde(rename = "function")]
452 Function,
453}
454
455#[derive(Debug, Clone, Serialize, Deserialize)]
456pub struct FunctionRemoteValue {
457 #[serde(rename = "type")]
458 pub r#type: FunctionEnum,
459 #[serde(rename = "handle")]
460 #[serde(skip_serializing_if = "Option::is_none")]
461 pub handle: Option<Handle>,
462 #[serde(rename = "internalId")]
463 #[serde(skip_serializing_if = "Option::is_none")]
464 pub internal_id: Option<InternalId>,
465}
466
467#[derive(Debug, Clone, Serialize, Deserialize)]
468pub struct RegExpRemoteValue {
469 #[serde(flatten)]
470 pub reg_exp_local_value: RegExpLocalValue,
471 #[serde(rename = "handle")]
472 #[serde(skip_serializing_if = "Option::is_none")]
473 pub handle: Option<Handle>,
474 #[serde(rename = "internalId")]
475 #[serde(skip_serializing_if = "Option::is_none")]
476 pub internal_id: Option<InternalId>,
477}
478
479#[derive(Debug, Clone, Serialize, Deserialize)]
480pub struct DateRemoteValue {
481 #[serde(flatten)]
482 pub date_local_value: DateLocalValue,
483 #[serde(rename = "handle")]
484 #[serde(skip_serializing_if = "Option::is_none")]
485 pub handle: Option<Handle>,
486 #[serde(rename = "internalId")]
487 #[serde(skip_serializing_if = "Option::is_none")]
488 pub internal_id: Option<InternalId>,
489}
490
491#[derive(Debug, Clone, Serialize, Deserialize)]
492pub struct MapRemoteValue {
493 #[serde(rename = "type")]
494 pub r#type: MapEnum,
495 #[serde(rename = "handle")]
496 #[serde(skip_serializing_if = "Option::is_none")]
497 pub handle: Option<Handle>,
498 #[serde(rename = "internalId")]
499 #[serde(skip_serializing_if = "Option::is_none")]
500 pub internal_id: Option<InternalId>,
501 #[serde(rename = "value")]
502 #[serde(skip_serializing_if = "Option::is_none")]
503 pub value: Option<MappingRemoteValue>,
504}
505
506#[derive(Debug, Clone, Serialize, Deserialize)]
507pub struct SetRemoteValue {
508 #[serde(rename = "type")]
509 pub r#type: SetEnum,
510 #[serde(rename = "handle")]
511 #[serde(skip_serializing_if = "Option::is_none")]
512 pub handle: Option<Handle>,
513 #[serde(rename = "internalId")]
514 #[serde(skip_serializing_if = "Option::is_none")]
515 pub internal_id: Option<InternalId>,
516 #[serde(rename = "value")]
517 #[serde(skip_serializing_if = "Option::is_none")]
518 pub value: Option<ListRemoteValue>,
519}
520
521#[derive(Debug, Clone, Serialize, Deserialize)]
522pub enum WeakmapEnum {
523 #[serde(rename = "weakmap")]
524 Weakmap,
525}
526
527#[derive(Debug, Clone, Serialize, Deserialize)]
528pub struct WeakMapRemoteValue {
529 #[serde(rename = "type")]
530 pub r#type: WeakmapEnum,
531 #[serde(rename = "handle")]
532 #[serde(skip_serializing_if = "Option::is_none")]
533 pub handle: Option<Handle>,
534 #[serde(rename = "internalId")]
535 #[serde(skip_serializing_if = "Option::is_none")]
536 pub internal_id: Option<InternalId>,
537}
538
539#[derive(Debug, Clone, Serialize, Deserialize)]
540pub enum WeaksetEnum {
541 #[serde(rename = "weakset")]
542 Weakset,
543}
544
545#[derive(Debug, Clone, Serialize, Deserialize)]
546pub struct WeakSetRemoteValue {
547 #[serde(rename = "type")]
548 pub r#type: WeaksetEnum,
549 #[serde(rename = "handle")]
550 #[serde(skip_serializing_if = "Option::is_none")]
551 pub handle: Option<Handle>,
552 #[serde(rename = "internalId")]
553 #[serde(skip_serializing_if = "Option::is_none")]
554 pub internal_id: Option<InternalId>,
555}
556
557#[derive(Debug, Clone, Serialize, Deserialize)]
558pub enum GeneratorEnum {
559 #[serde(rename = "generator")]
560 Generator,
561}
562
563#[derive(Debug, Clone, Serialize, Deserialize)]
564pub struct GeneratorRemoteValue {
565 #[serde(rename = "type")]
566 pub r#type: GeneratorEnum,
567 #[serde(rename = "handle")]
568 #[serde(skip_serializing_if = "Option::is_none")]
569 pub handle: Option<Handle>,
570 #[serde(rename = "internalId")]
571 #[serde(skip_serializing_if = "Option::is_none")]
572 pub internal_id: Option<InternalId>,
573}
574
575#[derive(Debug, Clone, Serialize, Deserialize)]
576pub enum ErrorEnum {
577 #[serde(rename = "error")]
578 Error,
579}
580
581#[derive(Debug, Clone, Serialize, Deserialize)]
582pub struct ErrorRemoteValue {
583 #[serde(rename = "type")]
584 pub r#type: ErrorEnum,
585 #[serde(rename = "handle")]
586 #[serde(skip_serializing_if = "Option::is_none")]
587 pub handle: Option<Handle>,
588 #[serde(rename = "internalId")]
589 #[serde(skip_serializing_if = "Option::is_none")]
590 pub internal_id: Option<InternalId>,
591}
592
593#[derive(Debug, Clone, Serialize, Deserialize)]
594pub enum ProxyEnum {
595 #[serde(rename = "proxy")]
596 Proxy,
597}
598
599#[derive(Debug, Clone, Serialize, Deserialize)]
600pub struct ProxyRemoteValue {
601 #[serde(rename = "type")]
602 pub r#type: ProxyEnum,
603 #[serde(rename = "handle")]
604 #[serde(skip_serializing_if = "Option::is_none")]
605 pub handle: Option<Handle>,
606 #[serde(rename = "internalId")]
607 #[serde(skip_serializing_if = "Option::is_none")]
608 pub internal_id: Option<InternalId>,
609}
610
611#[derive(Debug, Clone, Serialize, Deserialize)]
612pub enum PromiseEnum {
613 #[serde(rename = "promise")]
614 Promise,
615}
616
617#[derive(Debug, Clone, Serialize, Deserialize)]
618pub struct PromiseRemoteValue {
619 #[serde(rename = "type")]
620 pub r#type: PromiseEnum,
621 #[serde(rename = "handle")]
622 #[serde(skip_serializing_if = "Option::is_none")]
623 pub handle: Option<Handle>,
624 #[serde(rename = "internalId")]
625 #[serde(skip_serializing_if = "Option::is_none")]
626 pub internal_id: Option<InternalId>,
627}
628
629#[derive(Debug, Clone, Serialize, Deserialize)]
630pub enum TypedarrayEnum {
631 #[serde(rename = "typedarray")]
632 Typedarray,
633}
634
635#[derive(Debug, Clone, Serialize, Deserialize)]
636pub struct TypedArrayRemoteValue {
637 #[serde(rename = "type")]
638 pub r#type: TypedarrayEnum,
639 #[serde(rename = "handle")]
640 #[serde(skip_serializing_if = "Option::is_none")]
641 pub handle: Option<Handle>,
642 #[serde(rename = "internalId")]
643 #[serde(skip_serializing_if = "Option::is_none")]
644 pub internal_id: Option<InternalId>,
645}
646
647#[derive(Debug, Clone, Serialize, Deserialize)]
648pub enum ArraybufferEnum {
649 #[serde(rename = "arraybuffer")]
650 Arraybuffer,
651}
652
653#[derive(Debug, Clone, Serialize, Deserialize)]
654pub struct ArrayBufferRemoteValue {
655 #[serde(rename = "type")]
656 pub r#type: ArraybufferEnum,
657 #[serde(rename = "handle")]
658 #[serde(skip_serializing_if = "Option::is_none")]
659 pub handle: Option<Handle>,
660 #[serde(rename = "internalId")]
661 #[serde(skip_serializing_if = "Option::is_none")]
662 pub internal_id: Option<InternalId>,
663}
664
665#[derive(Debug, Clone, Serialize, Deserialize)]
666pub enum NodelistEnum {
667 #[serde(rename = "nodelist")]
668 Nodelist,
669}
670
671#[derive(Debug, Clone, Serialize, Deserialize)]
672pub struct NodeListRemoteValue {
673 #[serde(rename = "type")]
674 pub r#type: NodelistEnum,
675 #[serde(rename = "handle")]
676 #[serde(skip_serializing_if = "Option::is_none")]
677 pub handle: Option<Handle>,
678 #[serde(rename = "internalId")]
679 #[serde(skip_serializing_if = "Option::is_none")]
680 pub internal_id: Option<InternalId>,
681 #[serde(rename = "value")]
682 #[serde(skip_serializing_if = "Option::is_none")]
683 pub value: Option<ListRemoteValue>,
684}
685
686#[derive(Debug, Clone, Serialize, Deserialize)]
687pub enum HtmlcollectionEnum {
688 #[serde(rename = "htmlcollection")]
689 Htmlcollection,
690}
691
692#[derive(Debug, Clone, Serialize, Deserialize)]
693pub struct HTMLCollectionRemoteValue {
694 #[serde(rename = "type")]
695 pub r#type: HtmlcollectionEnum,
696 #[serde(rename = "handle")]
697 #[serde(skip_serializing_if = "Option::is_none")]
698 pub handle: Option<Handle>,
699 #[serde(rename = "internalId")]
700 #[serde(skip_serializing_if = "Option::is_none")]
701 pub internal_id: Option<InternalId>,
702 #[serde(rename = "value")]
703 #[serde(skip_serializing_if = "Option::is_none")]
704 pub value: Option<ListRemoteValue>,
705}
706
707#[derive(Debug, Clone, Serialize, Deserialize)]
708pub enum NodeEnum {
709 #[serde(rename = "node")]
710 Node,
711}
712
713#[derive(Debug, Clone, Serialize, Deserialize)]
714pub enum NodePropertiesModeUnion {
715 #[serde(rename = "open")]
716 Open,
717 #[serde(rename = "closed")]
718 Closed,
719}
720
721#[derive(Debug, Clone, Serialize, Deserialize)]
722pub struct NodeProperties {
723 #[serde(rename = "nodeType")]
724 pub node_type: u64,
725 #[serde(rename = "childNodeCount")]
726 pub child_node_count: u64,
727 #[serde(rename = "attributes")]
728 #[serde(skip_serializing_if = "Option::is_none")]
729 pub attributes: Option<std::collections::HashMap<String, String>>,
730 #[serde(rename = "children")]
731 #[serde(skip_serializing_if = "Option::is_none")]
732 pub children: Option<Vec<NodeRemoteValue>>,
733 #[serde(rename = "localName")]
734 #[serde(skip_serializing_if = "Option::is_none")]
735 pub local_name: Option<String>,
736 #[serde(rename = "mode")]
737 #[serde(skip_serializing_if = "Option::is_none")]
738 pub mode: Option<NodePropertiesModeUnion>,
739 #[serde(rename = "namespaceURI")]
740 #[serde(skip_serializing_if = "Option::is_none")]
741 pub namespace_uri: Option<String>,
742 #[serde(rename = "nodeValue")]
743 #[serde(skip_serializing_if = "Option::is_none")]
744 pub node_value: Option<String>,
745 #[serde(rename = "shadowRoot")]
746 #[serde(skip_serializing_if = "Option::is_none")]
747 pub shadow_root: Option<Option<Box<NodeRemoteValue>>>,
748}
749
750#[derive(Debug, Clone, Serialize, Deserialize)]
751pub struct NodeRemoteValue {
752 #[serde(rename = "type")]
753 pub r#type: NodeEnum,
754 #[serde(rename = "sharedId")]
755 #[serde(skip_serializing_if = "Option::is_none")]
756 pub shared_id: Option<SharedId>,
757 #[serde(rename = "handle")]
758 #[serde(skip_serializing_if = "Option::is_none")]
759 pub handle: Option<Handle>,
760 #[serde(rename = "internalId")]
761 #[serde(skip_serializing_if = "Option::is_none")]
762 pub internal_id: Option<InternalId>,
763 #[serde(rename = "value")]
764 #[serde(skip_serializing_if = "Option::is_none")]
765 pub value: Option<NodeProperties>,
766}
767
768#[derive(Debug, Clone, Serialize, Deserialize)]
769pub enum WindowEnum {
770 #[serde(rename = "window")]
771 Window,
772}
773
774#[derive(Debug, Clone, Serialize, Deserialize)]
775pub struct WindowProxyProperties {
776 #[serde(rename = "context")]
777 pub context: BrowsingContext,
778}
779
780#[derive(Debug, Clone, Serialize, Deserialize)]
781pub struct WindowProxyRemoteValue {
782 #[serde(rename = "type")]
783 pub r#type: WindowEnum,
784 #[serde(rename = "value")]
785 pub value: WindowProxyProperties,
786 #[serde(rename = "handle")]
787 #[serde(skip_serializing_if = "Option::is_none")]
788 pub handle: Option<Handle>,
789 #[serde(rename = "internalId")]
790 #[serde(skip_serializing_if = "Option::is_none")]
791 pub internal_id: Option<InternalId>,
792}
793
794#[derive(Debug, Clone, Serialize, Deserialize)]
795#[serde(untagged)]
796pub enum RemoteValue {
797 PrimitiveProtocolValue(PrimitiveProtocolValue),
798 SymbolRemoteValue(SymbolRemoteValue),
799 ArrayRemoteValue(ArrayRemoteValue),
800 ObjectRemoteValue(ObjectRemoteValue),
801 FunctionRemoteValue(FunctionRemoteValue),
802 RegExpRemoteValue(RegExpRemoteValue),
803 DateRemoteValue(DateRemoteValue),
804 MapRemoteValue(MapRemoteValue),
805 SetRemoteValue(SetRemoteValue),
806 WeakMapRemoteValue(WeakMapRemoteValue),
807 WeakSetRemoteValue(WeakSetRemoteValue),
808 GeneratorRemoteValue(GeneratorRemoteValue),
809 ErrorRemoteValue(ErrorRemoteValue),
810 ProxyRemoteValue(ProxyRemoteValue),
811 PromiseRemoteValue(PromiseRemoteValue),
812 TypedArrayRemoteValue(TypedArrayRemoteValue),
813 ArrayBufferRemoteValue(ArrayBufferRemoteValue),
814 NodeListRemoteValue(NodeListRemoteValue),
815 HTMLCollectionRemoteValue(HTMLCollectionRemoteValue),
816 NodeRemoteValue(NodeRemoteValue),
817 WindowProxyRemoteValue(WindowProxyRemoteValue),
818}
819
820#[derive(Debug, Clone, Serialize, Deserialize)]
821pub struct EvaluateResultSuccess {
822 #[serde(rename = "type")]
823 pub r#type: SuccessEnum,
824 #[serde(rename = "result")]
825 pub result: RemoteValue,
826 #[serde(rename = "realm")]
827 pub realm: Realm,
828}
829
830#[derive(Debug, Clone, Serialize, Deserialize)]
831pub enum ExceptionEnum {
832 #[serde(rename = "exception")]
833 Exception,
834}
835
836#[derive(Debug, Clone, Serialize, Deserialize)]
837pub struct StackFrame {
838 #[serde(rename = "columnNumber")]
839 pub column_number: u64,
840 #[serde(rename = "functionName")]
841 pub function_name: String,
842 #[serde(rename = "lineNumber")]
843 pub line_number: u64,
844 #[serde(rename = "url")]
845 pub url: String,
846}
847
848#[derive(Debug, Clone, Serialize, Deserialize)]
849pub struct StackTrace {
850 #[serde(rename = "callFrames")]
851 pub call_frames: Vec<StackFrame>,
852}
853
854#[derive(Debug, Clone, Serialize, Deserialize)]
855pub struct ExceptionDetails {
856 #[serde(rename = "columnNumber")]
857 pub column_number: u64,
858 #[serde(rename = "exception")]
859 pub exception: RemoteValue,
860 #[serde(rename = "lineNumber")]
861 pub line_number: u64,
862 #[serde(rename = "stackTrace")]
863 pub stack_trace: StackTrace,
864 #[serde(rename = "text")]
865 pub text: String,
866}
867
868#[derive(Debug, Clone, Serialize, Deserialize)]
869pub struct EvaluateResultException {
870 #[serde(rename = "type")]
871 pub r#type: ExceptionEnum,
872 #[serde(rename = "exceptionDetails")]
873 pub exception_details: ExceptionDetails,
874 #[serde(rename = "realm")]
875 pub realm: Realm,
876}
877
878#[derive(Debug, Clone, Serialize, Deserialize)]
879pub struct BaseRealmInfo {
880 #[serde(rename = "realm")]
881 pub realm: Realm,
882 #[serde(rename = "origin")]
883 pub origin: String,
884}
885
886#[derive(Debug, Clone, Serialize, Deserialize)]
887pub struct WindowRealmInfo {
888 #[serde(flatten)]
889 pub base_realm_info: BaseRealmInfo,
890 #[serde(rename = "type")]
891 pub r#type: WindowEnum,
892 #[serde(rename = "context")]
893 pub context: BrowsingContext,
894 #[serde(rename = "sandbox")]
895 #[serde(skip_serializing_if = "Option::is_none")]
896 pub sandbox: Option<String>,
897}
898
899#[derive(Debug, Clone, Serialize, Deserialize)]
900pub enum DedicatedWorkerEnum {
901 #[serde(rename = "dedicated-worker")]
902 DedicatedWorker,
903}
904
905#[derive(Debug, Clone, Serialize, Deserialize)]
906pub struct DedicatedWorkerRealmInfo {
907 #[serde(flatten)]
908 pub base_realm_info: BaseRealmInfo,
909 #[serde(rename = "type")]
910 pub r#type: DedicatedWorkerEnum,
911 #[serde(rename = "owners")]
912 pub owners: Realm,
913}
914
915#[derive(Debug, Clone, Serialize, Deserialize)]
916pub enum SharedWorkerEnum {
917 #[serde(rename = "shared-worker")]
918 SharedWorker,
919}
920
921#[derive(Debug, Clone, Serialize, Deserialize)]
922pub struct SharedWorkerRealmInfo {
923 #[serde(flatten)]
924 pub base_realm_info: BaseRealmInfo,
925 #[serde(rename = "type")]
926 pub r#type: SharedWorkerEnum,
927}
928
929#[derive(Debug, Clone, Serialize, Deserialize)]
930pub enum ServiceWorkerEnum {
931 #[serde(rename = "service-worker")]
932 ServiceWorker,
933}
934
935#[derive(Debug, Clone, Serialize, Deserialize)]
936pub struct ServiceWorkerRealmInfo {
937 #[serde(flatten)]
938 pub base_realm_info: BaseRealmInfo,
939 #[serde(rename = "type")]
940 pub r#type: ServiceWorkerEnum,
941}
942
943#[derive(Debug, Clone, Serialize, Deserialize)]
944pub enum WorkerEnum {
945 #[serde(rename = "worker")]
946 Worker,
947}
948
949#[derive(Debug, Clone, Serialize, Deserialize)]
950pub struct WorkerRealmInfo {
951 #[serde(flatten)]
952 pub base_realm_info: BaseRealmInfo,
953 #[serde(rename = "type")]
954 pub r#type: WorkerEnum,
955}
956
957#[derive(Debug, Clone, Serialize, Deserialize)]
958pub enum PaintWorkletEnum {
959 #[serde(rename = "paint-worklet")]
960 PaintWorklet,
961}
962
963#[derive(Debug, Clone, Serialize, Deserialize)]
964pub struct PaintWorkletRealmInfo {
965 #[serde(flatten)]
966 pub base_realm_info: BaseRealmInfo,
967 #[serde(rename = "type")]
968 pub r#type: PaintWorkletEnum,
969}
970
971#[derive(Debug, Clone, Serialize, Deserialize)]
972pub enum AudioWorkletEnum {
973 #[serde(rename = "audio-worklet")]
974 AudioWorklet,
975}
976
977#[derive(Debug, Clone, Serialize, Deserialize)]
978pub struct AudioWorkletRealmInfo {
979 #[serde(flatten)]
980 pub base_realm_info: BaseRealmInfo,
981 #[serde(rename = "type")]
982 pub r#type: AudioWorkletEnum,
983}
984
985#[derive(Debug, Clone, Serialize, Deserialize)]
986pub enum WorkletEnum {
987 #[serde(rename = "worklet")]
988 Worklet,
989}
990
991#[derive(Debug, Clone, Serialize, Deserialize)]
992pub struct WorkletRealmInfo {
993 #[serde(flatten)]
994 pub base_realm_info: BaseRealmInfo,
995 #[serde(rename = "type")]
996 pub r#type: WorkletEnum,
997}
998
999#[derive(Debug, Clone, Serialize, Deserialize)]
1000#[serde(untagged)]
1001pub enum RealmInfo {
1002 WindowRealmInfo(WindowRealmInfo),
1003 DedicatedWorkerRealmInfo(DedicatedWorkerRealmInfo),
1004 SharedWorkerRealmInfo(SharedWorkerRealmInfo),
1005 ServiceWorkerRealmInfo(ServiceWorkerRealmInfo),
1006 WorkerRealmInfo(WorkerRealmInfo),
1007 PaintWorkletRealmInfo(PaintWorkletRealmInfo),
1008 AudioWorkletRealmInfo(AudioWorkletRealmInfo),
1009 WorkletRealmInfo(WorkletRealmInfo),
1010}
1011
1012#[derive(Debug, Clone, Serialize, Deserialize)]
1013pub struct Source {
1014 #[serde(rename = "realm")]
1015 pub realm: Realm,
1016 #[serde(rename = "context")]
1017 #[serde(skip_serializing_if = "Option::is_none")]
1018 pub context: Option<BrowsingContext>,
1019}
1020
1021#[derive(Debug, Clone, Serialize, Deserialize)]
1022pub struct MessageParameters {
1023 #[serde(rename = "channel")]
1024 pub channel: Channel,
1025 #[serde(rename = "data")]
1026 pub data: RemoteValue,
1027 #[serde(rename = "source")]
1028 pub source: Source,
1029}
1030
1031#[derive(Debug, Clone, Serialize, Deserialize)]
1032pub struct RealmDestroyedParameters {
1033 #[serde(rename = "realm")]
1034 pub realm: Realm,
1035}
1036