rustenium_bidi_commands/session/
types.rs

1// Generated types for module
2
3use serde::{Serialize, Deserialize};
4use crate::{Extensible};
5use serde_valid::Validate;
6
7#[derive(Debug, Clone, Serialize, Deserialize)]
8pub enum AutodetectEnum {
9    #[serde(rename = "autodetect")]
10    Autodetect,
11}
12
13#[derive(Debug, Clone, Serialize, Deserialize)]
14pub struct AutodetectProxyConfiguration {
15    #[serde(rename = "proxyType")]
16    pub proxy_type: AutodetectEnum,
17    #[serde(flatten)]
18    pub extensible: Extensible,
19}
20
21#[derive(Debug, Clone, Serialize, Deserialize)]
22pub enum DirectEnum {
23    #[serde(rename = "direct")]
24    Direct,
25}
26
27#[derive(Debug, Clone, Serialize, Deserialize)]
28pub struct DirectProxyConfiguration {
29    #[serde(rename = "proxyType")]
30    pub proxy_type: DirectEnum,
31    #[serde(flatten)]
32    pub extensible: Extensible,
33}
34
35#[derive(Debug, Clone, Serialize, Deserialize)]
36pub enum ManualEnum {
37    #[serde(rename = "manual")]
38    Manual,
39}
40
41#[derive(Debug, Clone, Serialize, Deserialize, Validate)]
42pub struct SocksProxyConfiguration {
43    #[serde(rename = "socksProxy")]
44    pub socks_proxy: String,
45    #[serde(rename = "socksVersion")]
46    #[validate(minimum = 0)]
47    #[validate(maximum = 255)]
48    pub socks_version: i64,
49}
50
51#[derive(Debug, Clone, Serialize, Deserialize)]
52pub struct ManualProxyConfiguration {
53    #[serde(rename = "proxyType")]
54    pub proxy_type: ManualEnum,
55    #[serde(rename = "httpProxy")]
56    #[serde(skip_serializing_if = "Option::is_none")]
57    pub http_proxy: Option<String>,
58    #[serde(rename = "sslProxy")]
59    #[serde(skip_serializing_if = "Option::is_none")]
60    pub ssl_proxy: Option<String>,
61    #[serde(flatten)]
62    pub socks_proxy_configuration: Option<SocksProxyConfiguration>,
63    #[serde(rename = "noProxy")]
64    #[serde(skip_serializing_if = "Option::is_none")]
65    pub no_proxy: Option<Vec<String>>,
66    #[serde(flatten)]
67    pub extensible: Extensible,
68}
69
70#[derive(Debug, Clone, Serialize, Deserialize)]
71pub enum PacEnum {
72    #[serde(rename = "pac")]
73    Pac,
74}
75
76#[derive(Debug, Clone, Serialize, Deserialize)]
77pub struct PacProxyConfiguration {
78    #[serde(rename = "proxyType")]
79    pub proxy_type: PacEnum,
80    #[serde(rename = "proxyAutoconfigUrl")]
81    pub proxy_autoconfig_url: String,
82    #[serde(flatten)]
83    pub extensible: Extensible,
84}
85
86#[derive(Debug, Clone, Serialize, Deserialize)]
87pub enum SystemEnum {
88    #[serde(rename = "system")]
89    System,
90}
91
92#[derive(Debug, Clone, Serialize, Deserialize)]
93pub struct SystemProxyConfiguration {
94    #[serde(rename = "proxyType")]
95    pub proxy_type: SystemEnum,
96    #[serde(flatten)]
97    pub extensible: Extensible,
98}
99
100#[derive(Debug, Clone, Serialize, Deserialize)]
101#[serde(untagged)]
102pub enum ProxyConfiguration {
103    AutodetectProxyConfiguration(AutodetectProxyConfiguration),
104    DirectProxyConfiguration(DirectProxyConfiguration),
105    ManualProxyConfiguration(ManualProxyConfiguration),
106    PacProxyConfiguration(PacProxyConfiguration),
107    SystemProxyConfiguration(SystemProxyConfiguration),
108    Empty {},
109}
110
111#[derive(Debug, Clone, Serialize, Deserialize)]
112pub enum UserPromptHandlerType {
113    #[serde(rename = "accept")]
114    Accept,
115    #[serde(rename = "dismiss")]
116    Dismiss,
117    #[serde(rename = "ignore")]
118    Ignore,
119}
120
121#[derive(Debug, Clone, Serialize, Deserialize)]
122pub struct UserPromptHandler {
123    #[serde(rename = "alert")]
124    #[serde(skip_serializing_if = "Option::is_none")]
125    pub alert: Option<UserPromptHandlerType>,
126    #[serde(rename = "beforeUnload")]
127    #[serde(skip_serializing_if = "Option::is_none")]
128    pub before_unload: Option<UserPromptHandlerType>,
129    #[serde(rename = "confirm")]
130    #[serde(skip_serializing_if = "Option::is_none")]
131    pub confirm: Option<UserPromptHandlerType>,
132    #[serde(rename = "default")]
133    #[serde(skip_serializing_if = "Option::is_none")]
134    pub default: Option<UserPromptHandlerType>,
135    #[serde(rename = "file")]
136    #[serde(skip_serializing_if = "Option::is_none")]
137    pub file: Option<UserPromptHandlerType>,
138    #[serde(rename = "prompt")]
139    #[serde(skip_serializing_if = "Option::is_none")]
140    pub prompt: Option<UserPromptHandlerType>,
141}
142
143#[derive(Debug, Clone, Serialize, Deserialize)]
144pub struct CapabilityRequest {
145    #[serde(rename = "acceptInsecureCerts")]
146    #[serde(skip_serializing_if = "Option::is_none")]
147    pub accept_insecure_certs: Option<bool>,
148    #[serde(rename = "browserName")]
149    #[serde(skip_serializing_if = "Option::is_none")]
150    pub browser_name: Option<String>,
151    #[serde(rename = "browserVersion")]
152    #[serde(skip_serializing_if = "Option::is_none")]
153    pub browser_version: Option<String>,
154    #[serde(rename = "platformName")]
155    #[serde(skip_serializing_if = "Option::is_none")]
156    pub platform_name: Option<String>,
157    #[serde(rename = "proxy")]
158    #[serde(skip_serializing_if = "Option::is_none")]
159    pub proxy: Option<ProxyConfiguration>,
160    #[serde(rename = "unhandledPromptBehavior")]
161    #[serde(skip_serializing_if = "Option::is_none")]
162    pub unhandled_prompt_behavior: Option<UserPromptHandler>,
163    #[serde(flatten)]
164    pub extensible: Extensible,
165}
166
167#[derive(Debug, Clone, Serialize, Deserialize)]
168pub struct CapabilitiesRequest {
169    #[serde(rename = "alwaysMatch")]
170    #[serde(skip_serializing_if = "Option::is_none")]
171    pub always_match: Option<CapabilityRequest>,
172    #[serde(rename = "firstMatch")]
173    #[serde(skip_serializing_if = "Option::is_none")]
174    pub first_match: Option<Vec<CapabilityRequest>>,
175}
176
177#[derive(Debug, Clone, Serialize, Deserialize)]
178pub struct UnsubscribeByAttributesRequest {
179    #[serde(rename = "events")]
180    pub events: Vec<String>,
181}
182
183pub type Subscription = String;
184
185
186#[derive(Debug, Clone, Serialize, Deserialize)]
187pub struct UnsubscribeByIDRequest {
188    #[serde(rename = "subscriptions")]
189    pub subscriptions: Vec<Subscription>,
190}
191
192
193#[derive(Debug, Clone, Serialize, Deserialize)]
194#[serde(untagged)]
195pub enum NewResultCapabilitiesUnhandledPromptBehaviorUnion {
196    UserPromptHandler(UserPromptHandler),
197    String(String)
198}
199
200#[derive(Debug, Clone, Serialize, Deserialize)]
201pub struct NewResultCapabilities {
202    #[serde(rename = "acceptInsecureCerts")]
203    pub accept_insecure_certs: bool,
204    #[serde(rename = "browserName")]
205    pub browser_name: String,
206    #[serde(rename = "browserVersion")]
207    pub browser_version: String,
208    #[serde(rename = "platformName")]
209    pub platform_name: String,
210    #[serde(rename = "setWindowRect")]
211    pub set_window_rect: bool,
212    #[serde(rename = "userAgent")]
213    #[serde(skip_serializing_if = "Option::is_none")]
214    pub user_agent: Option<String>,
215    #[serde(rename = "proxy")]
216    #[serde(skip_serializing_if = "Option::is_none")]
217    pub proxy: Option<ProxyConfiguration>,
218    #[serde(rename = "unhandledPromptBehavior")]
219    #[serde(skip_serializing_if = "Option::is_none")]
220    pub unhandled_prompt_behavior: Option<NewResultCapabilitiesUnhandledPromptBehaviorUnion>,
221    #[serde(rename = "webSocketUrl")]
222    #[serde(skip_serializing_if = "Option::is_none")]
223    pub web_socket_url: Option<String>,
224    #[serde(flatten)]
225    pub extensible: Extensible,
226}
227