1#![allow(clippy::all, missing_docs, unused_imports)]
5
6use serde::{Deserialize, Serialize};
7
8use super::*;
9use crate::playwright::connection::{
10 Binary, Channel, ChannelType, ObjectRef, ProtocolError, ProtocolEvent, Ref,
11};
12
13#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
14pub struct LocalUtilsInitializerDeviceDescriptorsDescriptorViewport {
15 #[serde(rename = "width")]
16 pub width: i64,
17 #[serde(rename = "height")]
18 pub height: i64,
19}
20
21#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
22pub struct LocalUtilsInitializerDeviceDescriptorsDescriptorScreen {
23 #[serde(rename = "width")]
24 pub width: i64,
25 #[serde(rename = "height")]
26 pub height: i64,
27}
28
29#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
30pub enum LocalUtilsInitializerDeviceDescriptorsDescriptorDefaultBrowserType {
31 #[default]
32 #[serde(rename = "chromium")]
33 Chromium,
34 #[serde(rename = "firefox")]
35 Firefox,
36 #[serde(rename = "webkit")]
37 Webkit,
38}
39
40#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
41pub struct LocalUtilsInitializerDeviceDescriptorsDescriptor {
42 #[serde(rename = "userAgent")]
43 pub user_agent: String,
44 #[serde(rename = "viewport")]
45 pub viewport: LocalUtilsInitializerDeviceDescriptorsDescriptorViewport,
46 #[serde(rename = "screen", default, skip_serializing_if = "Option::is_none")]
47 pub screen: Option<LocalUtilsInitializerDeviceDescriptorsDescriptorScreen>,
48 #[serde(rename = "deviceScaleFactor")]
49 pub device_scale_factor: f64,
50 #[serde(rename = "isMobile")]
51 pub is_mobile: bool,
52 #[serde(rename = "hasTouch")]
53 pub has_touch: bool,
54 #[serde(rename = "defaultBrowserType")]
55 pub default_browser_type: LocalUtilsInitializerDeviceDescriptorsDescriptorDefaultBrowserType,
56}
57
58#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
59pub struct LocalUtilsInitializerDeviceDescriptors {
60 #[serde(rename = "name")]
61 pub name: String,
62 #[serde(rename = "descriptor")]
63 pub descriptor: LocalUtilsInitializerDeviceDescriptorsDescriptor,
64}
65
66#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
68pub struct LocalUtilsInitializer {
69 #[serde(rename = "deviceDescriptors")]
70 pub device_descriptors: Vec<LocalUtilsInitializerDeviceDescriptors>,
71}
72
73#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
74pub enum LocalUtilsZipParamsMode {
75 #[default]
76 #[serde(rename = "write")]
77 Write,
78 #[serde(rename = "append")]
79 Append,
80}
81
82#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
84pub struct LocalUtilsZipParams {
85 #[serde(rename = "zipFile")]
86 pub zip_file: String,
87 #[serde(rename = "entries")]
88 pub entries: Vec<NameValue>,
89 #[serde(rename = "stacksId", default, skip_serializing_if = "Option::is_none")]
90 pub stacks_id: Option<String>,
91 #[serde(rename = "mode")]
92 pub mode: LocalUtilsZipParamsMode,
93 #[serde(rename = "includeSources")]
94 pub include_sources: bool,
95 #[serde(rename = "additionalSources", default, skip_serializing_if = "Option::is_none")]
96 pub additional_sources: Option<Vec<String>>,
97}
98
99#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
101pub struct LocalUtilsHarOpenParams {
102 #[serde(rename = "file")]
103 pub file: String,
104}
105
106#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
108pub struct LocalUtilsHarOpenResult {
109 #[serde(rename = "harId", default, skip_serializing_if = "Option::is_none")]
110 pub har_id: Option<String>,
111 #[serde(rename = "error", default, skip_serializing_if = "Option::is_none")]
112 pub error: Option<String>,
113}
114
115#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
117pub struct LocalUtilsHarLookupParams {
118 #[serde(rename = "harId")]
119 pub har_id: String,
120 #[serde(rename = "url")]
121 pub url: String,
122 #[serde(rename = "method")]
123 pub method: String,
124 #[serde(rename = "headers")]
125 pub headers: Vec<NameValue>,
126 #[serde(rename = "postData", default, skip_serializing_if = "Option::is_none")]
127 pub post_data: Option<Binary>,
128 #[serde(rename = "isNavigationRequest")]
129 pub is_navigation_request: bool,
130}
131
132#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
133pub enum LocalUtilsHarLookupResultAction {
134 #[default]
135 #[serde(rename = "error")]
136 Error,
137 #[serde(rename = "redirect")]
138 Redirect,
139 #[serde(rename = "fulfill")]
140 Fulfill,
141 #[serde(rename = "noentry")]
142 Noentry,
143}
144
145#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
147pub struct LocalUtilsHarLookupResult {
148 #[serde(rename = "action")]
149 pub action: LocalUtilsHarLookupResultAction,
150 #[serde(rename = "message", default, skip_serializing_if = "Option::is_none")]
151 pub message: Option<String>,
152 #[serde(rename = "redirectURL", default, skip_serializing_if = "Option::is_none")]
153 pub redirect_url: Option<String>,
154 #[serde(rename = "status", default, skip_serializing_if = "Option::is_none")]
155 pub status: Option<i64>,
156 #[serde(rename = "headers", default, skip_serializing_if = "Option::is_none")]
157 pub headers: Option<Vec<NameValue>>,
158 #[serde(rename = "body", default, skip_serializing_if = "Option::is_none")]
159 pub body: Option<Binary>,
160}
161
162#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
164pub struct LocalUtilsHarCloseParams {
165 #[serde(rename = "harId")]
166 pub har_id: String,
167}
168
169#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
171pub struct LocalUtilsHarUnzipParams {
172 #[serde(rename = "zipFile")]
173 pub zip_file: String,
174 #[serde(rename = "harFile")]
175 pub har_file: String,
176 #[serde(rename = "resourcesDir", default, skip_serializing_if = "Option::is_none")]
177 pub resources_dir: Option<String>,
178}
179
180#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
182pub struct LocalUtilsConnectParams {
183 #[serde(rename = "endpoint")]
184 pub endpoint: String,
185 #[serde(rename = "headers", default, skip_serializing_if = "Option::is_none")]
186 pub headers: Option<serde_json::Value>,
187 #[serde(rename = "exposeNetwork", default, skip_serializing_if = "Option::is_none")]
188 pub expose_network: Option<String>,
189 #[serde(rename = "slowMo", default, skip_serializing_if = "Option::is_none")]
190 pub slow_mo: Option<f64>,
191 #[serde(rename = "socksProxyRedirectPortForTest", default, skip_serializing_if = "Option::is_none")]
192 pub socks_proxy_redirect_port_for_test: Option<i64>,
193}
194
195#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
197pub struct LocalUtilsConnectResult {
198 #[serde(rename = "pipe")]
199 pub pipe: Ref<JsonPipe>,
200 #[serde(rename = "headers")]
201 pub headers: Vec<NameValue>,
202}
203
204#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
206pub struct LocalUtilsTracingStartedParams {
207 #[serde(rename = "tracesDir", default, skip_serializing_if = "Option::is_none")]
208 pub traces_dir: Option<String>,
209 #[serde(rename = "traceName")]
210 pub trace_name: String,
211 #[serde(rename = "live", default, skip_serializing_if = "Option::is_none")]
212 pub live: Option<bool>,
213}
214
215#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
217pub struct LocalUtilsTracingStartedResult {
218 #[serde(rename = "stacksId")]
219 pub stacks_id: String,
220}
221
222#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
224pub struct LocalUtilsAddStackToTracingNoReplyParams {
225 #[serde(rename = "callData")]
226 pub call_data: ClientSideCallMetadata,
227}
228
229#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
231pub struct LocalUtilsTraceDiscardedParams {
232 #[serde(rename = "stacksId")]
233 pub stacks_id: String,
234}
235
236#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
238pub struct LocalUtilsGlobToRegexParams {
239 #[serde(rename = "glob")]
240 pub glob: String,
241 #[serde(rename = "baseURL", default, skip_serializing_if = "Option::is_none")]
242 pub base_url: Option<String>,
243 #[serde(rename = "webSocketUrl", default, skip_serializing_if = "Option::is_none")]
244 pub web_socket_url: Option<bool>,
245}
246
247#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
249pub struct LocalUtilsGlobToRegexResult {
250 #[serde(rename = "regex")]
251 pub regex: String,
252}
253
254#[derive(Debug, Clone, PartialEq)]
256pub enum LocalUtilsEvent {
257 Unknown {
259 method: String,
261 params: serde_json::Value,
263 },
264}
265
266impl ProtocolEvent for LocalUtilsEvent {
267 fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
268 match method {
269 _ => Ok(Self::Unknown { method: method.to_string(), params }),
270 }
271 }
272}
273
274#[derive(Debug, Clone)]
276pub struct LocalUtils {
277 channel: Channel,
278}
279
280impl ChannelType for LocalUtils {
281 const INTERFACE: &'static str = "LocalUtils";
282 type Initializer = LocalUtilsInitializer;
283 type Event = LocalUtilsEvent;
284
285 fn accepts(interface: &str) -> bool {
286 matches!(interface, "LocalUtils")
287 }
288
289 fn from_channel(channel: Channel) -> Self {
290 Self { channel }
291 }
292
293 fn channel(&self) -> &Channel {
294 &self.channel
295 }
296}
297
298impl LocalUtils {
299 pub async fn zip(&self, params: LocalUtilsZipParams) -> Result<(), ProtocolError> {
301 self.channel.send_no_result("zip", ¶ms).await
302 }
303
304 pub async fn har_open(&self, params: LocalUtilsHarOpenParams) -> Result<LocalUtilsHarOpenResult, ProtocolError> {
306 self.channel.send("harOpen", ¶ms).await
307 }
308
309 pub async fn har_lookup(&self, params: LocalUtilsHarLookupParams) -> Result<LocalUtilsHarLookupResult, ProtocolError> {
311 self.channel.send("harLookup", ¶ms).await
312 }
313
314 pub async fn har_close(&self, params: LocalUtilsHarCloseParams) -> Result<(), ProtocolError> {
316 self.channel.send_no_result("harClose", ¶ms).await
317 }
318
319 pub async fn har_unzip(&self, params: LocalUtilsHarUnzipParams) -> Result<(), ProtocolError> {
321 self.channel.send_no_result("harUnzip", ¶ms).await
322 }
323
324 pub async fn connect(&self, params: LocalUtilsConnectParams) -> Result<LocalUtilsConnectResult, ProtocolError> {
326 self.channel.send("connect", ¶ms).await
327 }
328
329 pub async fn tracing_started(&self, params: LocalUtilsTracingStartedParams) -> Result<LocalUtilsTracingStartedResult, ProtocolError> {
331 self.channel.send("tracingStarted", ¶ms).await
332 }
333
334 pub async fn add_stack_to_tracing_no_reply(&self, params: LocalUtilsAddStackToTracingNoReplyParams) -> Result<(), ProtocolError> {
336 self.channel.send_no_result("addStackToTracingNoReply", ¶ms).await
337 }
338
339 pub async fn trace_discarded(&self, params: LocalUtilsTraceDiscardedParams) -> Result<(), ProtocolError> {
341 self.channel.send_no_result("traceDiscarded", ¶ms).await
342 }
343
344 pub async fn glob_to_regex(&self, params: LocalUtilsGlobToRegexParams) -> Result<LocalUtilsGlobToRegexResult, ProtocolError> {
346 self.channel.send("globToRegex", ¶ms).await
347 }
348}