Skip to main content

browser_commander/playwright/protocol/
browser.rs

1// @generated by scripts/generate-playwright-protocol.mjs from
2// rust/protocol/playwright/*.yml. Do not edit by hand.
3
4#![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, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
14pub enum BrowserInitializerBrowserName {
15    #[default]
16    #[serde(rename = "chromium")]
17    Chromium,
18    #[serde(rename = "firefox")]
19    Firefox,
20    #[serde(rename = "webkit")]
21    Webkit,
22}
23
24/// Initializer the driver sends when it creates a `Browser`.
25#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
26pub struct BrowserInitializer {
27    #[serde(rename = "version")]
28    pub version: String,
29    #[serde(rename = "name")]
30    pub name: String,
31    #[serde(rename = "browserName")]
32    pub browser_name: BrowserInitializerBrowserName,
33}
34
35/// Parameters of `Browser.startServer` (Start server).
36#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
37pub struct BrowserStartServerParams {
38    #[serde(rename = "title")]
39    pub title: String,
40    #[serde(rename = "workspaceDir", default, skip_serializing_if = "Option::is_none")]
41    pub workspace_dir: Option<String>,
42    #[serde(rename = "metadata", default, skip_serializing_if = "Option::is_none")]
43    pub metadata: Option<serde_json::Value>,
44    #[serde(rename = "host", default, skip_serializing_if = "Option::is_none")]
45    pub host: Option<String>,
46    #[serde(rename = "port", default, skip_serializing_if = "Option::is_none")]
47    pub port: Option<i64>,
48}
49
50/// Result of `Browser.startServer` (Start server).
51#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
52pub struct BrowserStartServerResult {
53    #[serde(rename = "endpoint")]
54    pub endpoint: String,
55}
56
57/// Parameters of `Browser.close` (Close browser).
58#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
59pub struct BrowserCloseParams {
60    #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
61    pub reason: Option<String>,
62}
63
64/// Result of `Browser.defaultUserAgentForTest`.
65#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
66pub struct BrowserDefaultUserAgentForTestResult {
67    #[serde(rename = "userAgent")]
68    pub user_agent: String,
69}
70
71#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
72pub struct BrowserNewContextParamsProxy {
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 BrowserNewContextParamsStorageState {
85    #[serde(rename = "cookies", default, skip_serializing_if = "Option::is_none")]
86    pub cookies: Option<Vec<SetNetworkCookie>>,
87    #[serde(rename = "origins", default, skip_serializing_if = "Option::is_none")]
88    pub origins: Option<Vec<SetOriginStorage>>,
89    #[serde(rename = "credentials", default, skip_serializing_if = "Option::is_none")]
90    pub credentials: Option<Vec<VirtualCredential>>,
91}
92
93/// Parameters of `Browser.newContext` (Create context).
94#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
95pub struct BrowserNewContextParams {
96    /// Properties of the `ContextOptions` mixin.
97    #[serde(flatten)]
98    pub context_options: ContextOptions,
99    #[serde(rename = "proxy", default, skip_serializing_if = "Option::is_none")]
100    pub proxy: Option<BrowserNewContextParamsProxy>,
101    #[serde(rename = "storageState", default, skip_serializing_if = "Option::is_none")]
102    pub storage_state: Option<BrowserNewContextParamsStorageState>,
103}
104
105/// Result of `Browser.newContext` (Create context).
106#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
107pub struct BrowserNewContextResult {
108    #[serde(rename = "context")]
109    pub context: Ref<BrowserContext>,
110}
111
112#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
113pub struct BrowserNewContextForReuseParamsProxy {
114    #[serde(rename = "server")]
115    pub server: String,
116    #[serde(rename = "bypass", default, skip_serializing_if = "Option::is_none")]
117    pub bypass: Option<String>,
118    #[serde(rename = "username", default, skip_serializing_if = "Option::is_none")]
119    pub username: Option<String>,
120    #[serde(rename = "password", default, skip_serializing_if = "Option::is_none")]
121    pub password: Option<String>,
122}
123
124#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
125pub struct BrowserNewContextForReuseParamsStorageState {
126    #[serde(rename = "cookies", default, skip_serializing_if = "Option::is_none")]
127    pub cookies: Option<Vec<SetNetworkCookie>>,
128    #[serde(rename = "origins", default, skip_serializing_if = "Option::is_none")]
129    pub origins: Option<Vec<SetOriginStorage>>,
130    #[serde(rename = "credentials", default, skip_serializing_if = "Option::is_none")]
131    pub credentials: Option<Vec<VirtualCredential>>,
132}
133
134/// Parameters of `Browser.newContextForReuse`.
135#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
136pub struct BrowserNewContextForReuseParams {
137    /// Properties of the `ContextOptions` mixin.
138    #[serde(flatten)]
139    pub context_options: ContextOptions,
140    #[serde(rename = "proxy", default, skip_serializing_if = "Option::is_none")]
141    pub proxy: Option<BrowserNewContextForReuseParamsProxy>,
142    #[serde(rename = "storageState", default, skip_serializing_if = "Option::is_none")]
143    pub storage_state: Option<BrowserNewContextForReuseParamsStorageState>,
144}
145
146/// Result of `Browser.newContextForReuse`.
147#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
148pub struct BrowserNewContextForReuseResult {
149    #[serde(rename = "context")]
150    pub context: Ref<BrowserContext>,
151}
152
153/// Parameters of `Browser.disconnectFromReusedContext`.
154#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
155pub struct BrowserDisconnectFromReusedContextParams {
156    #[serde(rename = "reason")]
157    pub reason: String,
158}
159
160/// Result of `Browser.newBrowserCDPSession` (Create CDP session).
161#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
162pub struct BrowserNewBrowserCDPSessionResult {
163    #[serde(rename = "session")]
164    pub session: Ref<CDPSession>,
165}
166
167/// Parameters of `Browser.startTracing` (Start browser tracing).
168#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
169pub struct BrowserStartTracingParams {
170    #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
171    pub page: Option<Ref<Page>>,
172    #[serde(rename = "screenshots", default, skip_serializing_if = "Option::is_none")]
173    pub screenshots: Option<bool>,
174    #[serde(rename = "categories", default, skip_serializing_if = "Option::is_none")]
175    pub categories: Option<Vec<String>>,
176}
177
178/// Result of `Browser.stopTracing` (Stop browser tracing).
179#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
180pub struct BrowserStopTracingResult {
181    #[serde(rename = "artifact")]
182    pub artifact: Ref<Artifact>,
183}
184
185/// Payload of the `Browser.context` event.
186#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
187pub struct BrowserContextEventParams {
188    #[serde(rename = "context")]
189    pub context: Ref<BrowserContext>,
190}
191
192/// Events a `Browser` channel can emit.
193#[derive(Debug, Clone, PartialEq)]
194pub enum BrowserEvent {
195    /// `Browser.context`
196    Context(BrowserContextEventParams),
197    /// `Browser.close`
198    Close,
199    /// An event this binding does not know (a newer driver).
200    Unknown {
201        /// Event name.
202        method: String,
203        /// Raw event parameters.
204        params: serde_json::Value,
205    },
206}
207
208impl ProtocolEvent for BrowserEvent {
209    fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
210        match method {
211            "context" => Ok(Self::Context(serde_json::from_value(params)?)),
212            "close" => Ok(Self::Close),
213            _ => Ok(Self::Unknown { method: method.to_string(), params }),
214        }
215    }
216}
217
218/// Channel for the `Browser` interface (`browser.yml`).
219#[derive(Debug, Clone)]
220pub struct Browser {
221    channel: Channel,
222}
223
224impl ChannelType for Browser {
225    const INTERFACE: &'static str = "Browser";
226    type Initializer = BrowserInitializer;
227    type Event = BrowserEvent;
228
229    fn accepts(interface: &str) -> bool {
230        matches!(interface, "Browser")
231    }
232
233    fn from_channel(channel: Channel) -> Self {
234        Self { channel }
235    }
236
237    fn channel(&self) -> &Channel {
238        &self.channel
239    }
240}
241
242impl Browser {
243    /// `Browser.startServer` ("Start server").
244    pub async fn start_server(&self, params: BrowserStartServerParams) -> Result<BrowserStartServerResult, ProtocolError> {
245        self.channel.send("startServer", &params).await
246    }
247
248    /// `Browser.stopServer` ("Stop server").
249    pub async fn stop_server(&self) -> Result<(), ProtocolError> {
250        self.channel.send_no_result("stopServer", &serde_json::json!({})).await
251    }
252
253    /// `Browser.close` ("Close browser").
254    pub async fn close(&self, params: BrowserCloseParams) -> Result<(), ProtocolError> {
255        self.channel.send_no_result("close", &params).await
256    }
257
258    /// `Browser.killForTests` (internal).
259    pub async fn kill_for_tests(&self) -> Result<(), ProtocolError> {
260        self.channel.send_no_result("killForTests", &serde_json::json!({})).await
261    }
262
263    /// `Browser.defaultUserAgentForTest` (internal).
264    pub async fn default_user_agent_for_test(&self) -> Result<BrowserDefaultUserAgentForTestResult, ProtocolError> {
265        self.channel.send("defaultUserAgentForTest", &serde_json::json!({})).await
266    }
267
268    /// `Browser.newContext` ("Create context").
269    pub async fn new_context(&self, params: BrowserNewContextParams) -> Result<BrowserNewContextResult, ProtocolError> {
270        self.channel.send("newContext", &params).await
271    }
272
273    /// `Browser.newContextForReuse` (internal).
274    pub async fn new_context_for_reuse(&self, params: BrowserNewContextForReuseParams) -> Result<BrowserNewContextForReuseResult, ProtocolError> {
275        self.channel.send("newContextForReuse", &params).await
276    }
277
278    /// `Browser.disconnectFromReusedContext` (internal).
279    pub async fn disconnect_from_reused_context(&self, params: BrowserDisconnectFromReusedContextParams) -> Result<(), ProtocolError> {
280        self.channel.send_no_result("disconnectFromReusedContext", &params).await
281    }
282
283    /// `Browser.newBrowserCDPSession` ("Create CDP session").
284    pub async fn new_browser_cdp_session(&self) -> Result<BrowserNewBrowserCDPSessionResult, ProtocolError> {
285        self.channel.send("newBrowserCDPSession", &serde_json::json!({})).await
286    }
287
288    /// `Browser.startTracing` ("Start browser tracing").
289    pub async fn start_tracing(&self, params: BrowserStartTracingParams) -> Result<(), ProtocolError> {
290        self.channel.send_no_result("startTracing", &params).await
291    }
292
293    /// `Browser.stopTracing` ("Stop browser tracing").
294    pub async fn stop_tracing(&self) -> Result<BrowserStopTracingResult, ProtocolError> {
295        self.channel.send("stopTracing", &serde_json::json!({})).await
296    }
297}