rustenium-bidi-definitions 0.1.1

Generated WebDriver BiDi protocol type definitions for Rustenium
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StatusParams {}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum StatusMethod {
    #[serde(rename = "session.status")]
    Status,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Status {
    pub method: StatusMethod,
    pub params: StatusParams,
}
impl Status {
    pub const IDENTIFIER: &'static str = "session.status";
    pub const DOMAIN_DIRECTION: &'static str = "remote";
    pub fn identifier(&self) -> &'static str {
        Self::IDENTIFIER
    }
}
impl crate::CommandResult for Status {
    type Result = super::results::StatusResult;
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NewParams {
    #[serde(rename = "capabilities")]
    pub capabilities: super::types::CapabilitiesRequest,
}
impl NewParams {
    pub fn new(capabilities: impl Into<super::types::CapabilitiesRequest>) -> Self {
        Self {
            capabilities: capabilities.into(),
        }
    }
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum NewMethod {
    #[serde(rename = "session.new")]
    New,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct New {
    pub method: NewMethod,
    pub params: NewParams,
}
impl New {
    pub const IDENTIFIER: &'static str = "session.new";
    pub const DOMAIN_DIRECTION: &'static str = "remote";
    pub fn identifier(&self) -> &'static str {
        Self::IDENTIFIER
    }
}
impl crate::CommandResult for New {
    type Result = super::results::NewResult;
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EndParams {}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum EndMethod {
    #[serde(rename = "session.end")]
    End,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct End {
    pub method: EndMethod,
    pub params: EndParams,
}
impl End {
    pub const IDENTIFIER: &'static str = "session.end";
    pub const DOMAIN_DIRECTION: &'static str = "remote";
    pub fn identifier(&self) -> &'static str {
        Self::IDENTIFIER
    }
}
impl crate::CommandResult for End {
    type Result = super::results::EndResult;
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SubscribeParams {
    #[serde(rename = "events")]
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub events: Vec<String>,
    #[serde(rename = "contexts")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(default)]
    pub contexts: Option<Vec<crate::browsing_context::types::BrowsingContext>>,
    #[serde(rename = "userContexts")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(default)]
    pub user_contexts: Option<Vec<crate::browser::types::UserContext>>,
}
impl SubscribeParams {
    pub fn new(events: Vec<String>) -> Self {
        Self {
            events,
            contexts: None,
            user_contexts: None,
        }
    }
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum SubscribeMethod {
    #[serde(rename = "session.subscribe")]
    Subscribe,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Subscribe {
    pub method: SubscribeMethod,
    pub params: SubscribeParams,
}
impl Subscribe {
    pub const IDENTIFIER: &'static str = "session.subscribe";
    pub const DOMAIN_DIRECTION: &'static str = "remote";
    pub fn identifier(&self) -> &'static str {
        Self::IDENTIFIER
    }
}
impl crate::CommandResult for Subscribe {
    type Result = super::results::SubscribeResult;
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UnsubscribeParams {
    #[serde(flatten)]
    #[serde(default)]
    pub unsubscribe_parameters: super::types::UnsubscribeParameters,
}
impl UnsubscribeParams {
    pub fn new(unsubscribe_parameters: impl Into<super::types::UnsubscribeParameters>) -> Self {
        Self {
            unsubscribe_parameters: unsubscribe_parameters.into(),
        }
    }
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum UnsubscribeMethod {
    #[serde(rename = "session.unsubscribe")]
    Unsubscribe,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Unsubscribe {
    pub method: UnsubscribeMethod,
    pub params: UnsubscribeParams,
}
impl Unsubscribe {
    pub const IDENTIFIER: &'static str = "session.unsubscribe";
    pub const DOMAIN_DIRECTION: &'static str = "remote";
    pub fn identifier(&self) -> &'static str {
        Self::IDENTIFIER
    }
}
impl crate::CommandResult for Unsubscribe {
    type Result = super::results::UnsubscribeResult;
}
group_enum ! (SessionCommand { Status (Status) , New (New) , End (End) , Subscribe (Subscribe) , Unsubscribe (Unsubscribe) } + identifiable);