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)]
15pub struct PlaywrightInitializer {
16 #[serde(rename = "chromium")]
17 pub chromium: Ref<BrowserType>,
18 #[serde(rename = "firefox")]
19 pub firefox: Ref<BrowserType>,
20 #[serde(rename = "webkit")]
21 pub webkit: Ref<BrowserType>,
22 #[serde(rename = "android")]
23 pub android: Ref<Android>,
24 #[serde(rename = "electron")]
25 pub electron: Ref<Electron>,
26 #[serde(rename = "utils", default, skip_serializing_if = "Option::is_none")]
27 pub utils: Option<Ref<LocalUtils>>,
28 #[serde(rename = "preLaunchedBrowser", default, skip_serializing_if = "Option::is_none")]
29 pub pre_launched_browser: Option<Ref<Browser>>,
30 #[serde(rename = "preConnectedAndroidDevice", default, skip_serializing_if = "Option::is_none")]
31 pub pre_connected_android_device: Option<Ref<AndroidDevice>>,
32 #[serde(rename = "socksSupport", default, skip_serializing_if = "Option::is_none")]
33 pub socks_support: Option<Ref<SocksSupport>>,
34}
35
36#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
37pub struct PlaywrightNewRequestParamsClientCertificates {
38 #[serde(rename = "origin")]
39 pub origin: String,
40 #[serde(rename = "cert", default, skip_serializing_if = "Option::is_none")]
41 pub cert: Option<Binary>,
42 #[serde(rename = "key", default, skip_serializing_if = "Option::is_none")]
43 pub key: Option<Binary>,
44 #[serde(rename = "passphrase", default, skip_serializing_if = "Option::is_none")]
45 pub passphrase: Option<String>,
46 #[serde(rename = "pfx", default, skip_serializing_if = "Option::is_none")]
47 pub pfx: Option<Binary>,
48}
49
50#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
51pub enum PlaywrightNewRequestParamsHttpCredentialsSend {
52 #[default]
53 #[serde(rename = "always")]
54 Always,
55 #[serde(rename = "unauthorized")]
56 Unauthorized,
57}
58
59#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
60pub struct PlaywrightNewRequestParamsHttpCredentials {
61 #[serde(rename = "username")]
62 pub username: String,
63 #[serde(rename = "password")]
64 pub password: String,
65 #[serde(rename = "origin", default, skip_serializing_if = "Option::is_none")]
66 pub origin: Option<String>,
67 #[serde(rename = "send", default, skip_serializing_if = "Option::is_none")]
68 pub send: Option<PlaywrightNewRequestParamsHttpCredentialsSend>,
69}
70
71#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
72pub struct PlaywrightNewRequestParamsProxy {
73 #[serde(rename = "server")]
74 pub server: String,
75 #[serde(rename = "bypass", default, skip_serializing_if = "Option::is_none")]
76 pub bypass: Option<String>,
77 #[serde(rename = "username", default, skip_serializing_if = "Option::is_none")]
78 pub username: Option<String>,
79 #[serde(rename = "password", default, skip_serializing_if = "Option::is_none")]
80 pub password: Option<String>,
81}
82
83#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
84pub struct PlaywrightNewRequestParamsStorageState {
85 #[serde(rename = "cookies", default, skip_serializing_if = "Option::is_none")]
86 pub cookies: Option<Vec<NetworkCookie>>,
87 #[serde(rename = "origins", default, skip_serializing_if = "Option::is_none")]
88 pub origins: Option<Vec<SetOriginStorage>>,
89}
90
91#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
93pub struct PlaywrightNewRequestParams {
94 #[serde(rename = "baseURL", default, skip_serializing_if = "Option::is_none")]
95 pub base_url: Option<String>,
96 #[serde(rename = "userAgent", default, skip_serializing_if = "Option::is_none")]
97 pub user_agent: Option<String>,
98 #[serde(rename = "ignoreHTTPSErrors", default, skip_serializing_if = "Option::is_none")]
99 pub ignore_https_errors: Option<bool>,
100 #[serde(rename = "extraHTTPHeaders", default, skip_serializing_if = "Option::is_none")]
101 pub extra_http_headers: Option<Vec<NameValue>>,
102 #[serde(rename = "failOnStatusCode", default, skip_serializing_if = "Option::is_none")]
103 pub fail_on_status_code: Option<bool>,
104 #[serde(rename = "clientCertificates", default, skip_serializing_if = "Option::is_none")]
105 pub client_certificates: Option<Vec<PlaywrightNewRequestParamsClientCertificates>>,
106 #[serde(rename = "maxRedirects", default, skip_serializing_if = "Option::is_none")]
107 pub max_redirects: Option<i64>,
108 #[serde(rename = "httpCredentials", default, skip_serializing_if = "Option::is_none")]
109 pub http_credentials: Option<PlaywrightNewRequestParamsHttpCredentials>,
110 #[serde(rename = "proxy", default, skip_serializing_if = "Option::is_none")]
111 pub proxy: Option<PlaywrightNewRequestParamsProxy>,
112 #[serde(rename = "storageState", default, skip_serializing_if = "Option::is_none")]
113 pub storage_state: Option<PlaywrightNewRequestParamsStorageState>,
114 #[serde(rename = "tracesDir", default, skip_serializing_if = "Option::is_none")]
115 pub traces_dir: Option<String>,
116}
117
118#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
120pub struct PlaywrightNewRequestResult {
121 #[serde(rename = "request")]
122 pub request: Ref<APIRequestContext>,
123}
124
125#[derive(Debug, Clone, PartialEq)]
127pub enum PlaywrightEvent {
128 Unknown {
130 method: String,
132 params: serde_json::Value,
134 },
135}
136
137impl ProtocolEvent for PlaywrightEvent {
138 fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
139 match method {
140 _ => Ok(Self::Unknown { method: method.to_string(), params }),
141 }
142 }
143}
144
145#[derive(Debug, Clone)]
147pub struct Playwright {
148 channel: Channel,
149}
150
151impl ChannelType for Playwright {
152 const INTERFACE: &'static str = "Playwright";
153 type Initializer = PlaywrightInitializer;
154 type Event = PlaywrightEvent;
155
156 fn accepts(interface: &str) -> bool {
157 matches!(interface, "Playwright")
158 }
159
160 fn from_channel(channel: Channel) -> Self {
161 Self { channel }
162 }
163
164 fn channel(&self) -> &Channel {
165 &self.channel
166 }
167}
168
169impl Playwright {
170 pub async fn new_request(&self, params: PlaywrightNewRequestParams) -> Result<PlaywrightNewRequestResult, ProtocolError> {
172 self.channel.send("newRequest", ¶ms).await
173 }
174}