Skip to main content

browser_commander/playwright/protocol/
browser_context.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, Default, PartialEq, Serialize, Deserialize)]
14pub struct BrowserContextInitializerOptions {
15    /// Properties of the `ContextOptions` mixin.
16    #[serde(flatten)]
17    pub context_options: ContextOptions,
18}
19
20/// Initializer the driver sends when it creates a `BrowserContext`.
21#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
22pub struct BrowserContextInitializer {
23    #[serde(rename = "debugger")]
24    pub debugger: Ref<Debugger>,
25    #[serde(rename = "requestContext")]
26    pub request_context: Ref<APIRequestContext>,
27    #[serde(rename = "tracing")]
28    pub tracing: Ref<Tracing>,
29    #[serde(rename = "options")]
30    pub options: BrowserContextInitializerOptions,
31}
32
33/// Parameters of `BrowserContext.addCookies` (Add cookies).
34#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
35pub struct BrowserContextAddCookiesParams {
36    #[serde(rename = "cookies")]
37    pub cookies: Vec<SetNetworkCookie>,
38}
39
40/// Parameters of `BrowserContext.addInitScript` (Add init script).
41#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
42pub struct BrowserContextAddInitScriptParams {
43    #[serde(rename = "source")]
44    pub source: String,
45}
46
47/// Result of `BrowserContext.addInitScript` (Add init script).
48#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
49pub struct BrowserContextAddInitScriptResult {
50    #[serde(rename = "disposable")]
51    pub disposable: Ref<Disposable>,
52}
53
54/// Parameters of `BrowserContext.clearCookies` (Clear cookies).
55#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
56pub struct BrowserContextClearCookiesParams {
57    #[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
58    pub name: Option<String>,
59    #[serde(rename = "nameRegexSource", default, skip_serializing_if = "Option::is_none")]
60    pub name_regex_source: Option<String>,
61    #[serde(rename = "nameRegexFlags", default, skip_serializing_if = "Option::is_none")]
62    pub name_regex_flags: Option<String>,
63    #[serde(rename = "domain", default, skip_serializing_if = "Option::is_none")]
64    pub domain: Option<String>,
65    #[serde(rename = "domainRegexSource", default, skip_serializing_if = "Option::is_none")]
66    pub domain_regex_source: Option<String>,
67    #[serde(rename = "domainRegexFlags", default, skip_serializing_if = "Option::is_none")]
68    pub domain_regex_flags: Option<String>,
69    #[serde(rename = "path", default, skip_serializing_if = "Option::is_none")]
70    pub path: Option<String>,
71    #[serde(rename = "pathRegexSource", default, skip_serializing_if = "Option::is_none")]
72    pub path_regex_source: Option<String>,
73    #[serde(rename = "pathRegexFlags", default, skip_serializing_if = "Option::is_none")]
74    pub path_regex_flags: Option<String>,
75}
76
77/// Parameters of `BrowserContext.close` (Close context).
78#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
79pub struct BrowserContextCloseParams {
80    #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
81    pub reason: Option<String>,
82}
83
84/// Parameters of `BrowserContext.cookies` (Get cookies).
85#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
86pub struct BrowserContextCookiesParams {
87    #[serde(rename = "urls")]
88    pub urls: Vec<String>,
89}
90
91/// Result of `BrowserContext.cookies` (Get cookies).
92#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
93pub struct BrowserContextCookiesResult {
94    #[serde(rename = "cookies")]
95    pub cookies: Vec<NetworkCookie>,
96}
97
98/// Parameters of `BrowserContext.exposeBinding` (Expose binding).
99#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
100pub struct BrowserContextExposeBindingParams {
101    #[serde(rename = "name")]
102    pub name: String,
103    #[serde(rename = "noGlobal", default, skip_serializing_if = "Option::is_none")]
104    pub no_global: Option<bool>,
105}
106
107/// Result of `BrowserContext.exposeBinding` (Expose binding).
108#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
109pub struct BrowserContextExposeBindingResult {
110    #[serde(rename = "disposable")]
111    pub disposable: Ref<Disposable>,
112}
113
114/// Parameters of `BrowserContext.grantPermissions` (Grant permissions).
115#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
116pub struct BrowserContextGrantPermissionsParams {
117    #[serde(rename = "permissions")]
118    pub permissions: Vec<String>,
119    #[serde(rename = "origin", default, skip_serializing_if = "Option::is_none")]
120    pub origin: Option<String>,
121}
122
123/// Result of `BrowserContext.newPage` (Create page).
124#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
125pub struct BrowserContextNewPageResult {
126    #[serde(rename = "page")]
127    pub page: Ref<Page>,
128}
129
130/// Parameters of `BrowserContext.registerSelectorEngine`.
131#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
132pub struct BrowserContextRegisterSelectorEngineParams {
133    #[serde(rename = "selectorEngine")]
134    pub selector_engine: SelectorEngine,
135}
136
137/// Parameters of `BrowserContext.setTestIdAttributeName`.
138#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
139pub struct BrowserContextSetTestIdAttributeNameParams {
140    #[serde(rename = "testIdAttributeName")]
141    pub test_id_attribute_name: String,
142}
143
144/// Parameters of `BrowserContext.setExtraHTTPHeaders` (Set extra HTTP headers).
145#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
146pub struct BrowserContextSetExtraHTTPHeadersParams {
147    #[serde(rename = "headers")]
148    pub headers: Vec<NameValue>,
149}
150
151#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
152pub struct BrowserContextSetGeolocationParamsGeolocation {
153    #[serde(rename = "longitude")]
154    pub longitude: f64,
155    #[serde(rename = "latitude")]
156    pub latitude: f64,
157    #[serde(rename = "accuracy", default, skip_serializing_if = "Option::is_none")]
158    pub accuracy: Option<f64>,
159}
160
161/// Parameters of `BrowserContext.setGeolocation` (Set geolocation).
162#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
163pub struct BrowserContextSetGeolocationParams {
164    #[serde(rename = "geolocation", default, skip_serializing_if = "Option::is_none")]
165    pub geolocation: Option<BrowserContextSetGeolocationParamsGeolocation>,
166}
167
168#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
169pub struct BrowserContextSetHTTPCredentialsParamsHttpCredentials {
170    #[serde(rename = "username")]
171    pub username: String,
172    #[serde(rename = "password")]
173    pub password: String,
174    #[serde(rename = "origin", default, skip_serializing_if = "Option::is_none")]
175    pub origin: Option<String>,
176}
177
178/// Parameters of `BrowserContext.setHTTPCredentials` (Set HTTP credentials).
179#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
180pub struct BrowserContextSetHTTPCredentialsParams {
181    #[serde(rename = "httpCredentials", default, skip_serializing_if = "Option::is_none")]
182    pub http_credentials: Option<BrowserContextSetHTTPCredentialsParamsHttpCredentials>,
183}
184
185#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
186pub struct BrowserContextSetNetworkInterceptionPatternsParamsPatterns {
187    #[serde(rename = "glob", default, skip_serializing_if = "Option::is_none")]
188    pub glob: Option<String>,
189    #[serde(rename = "regexSource", default, skip_serializing_if = "Option::is_none")]
190    pub regex_source: Option<String>,
191    #[serde(rename = "regexFlags", default, skip_serializing_if = "Option::is_none")]
192    pub regex_flags: Option<String>,
193    #[serde(rename = "urlPattern", default, skip_serializing_if = "Option::is_none")]
194    pub url_pattern: Option<URLPattern>,
195}
196
197/// Parameters of `BrowserContext.setNetworkInterceptionPatterns` (Route requests).
198#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
199pub struct BrowserContextSetNetworkInterceptionPatternsParams {
200    #[serde(rename = "patterns")]
201    pub patterns: Vec<BrowserContextSetNetworkInterceptionPatternsParamsPatterns>,
202}
203
204#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
205pub struct BrowserContextSetWebSocketInterceptionPatternsParamsPatterns {
206    #[serde(rename = "glob", default, skip_serializing_if = "Option::is_none")]
207    pub glob: Option<String>,
208    #[serde(rename = "regexSource", default, skip_serializing_if = "Option::is_none")]
209    pub regex_source: Option<String>,
210    #[serde(rename = "regexFlags", default, skip_serializing_if = "Option::is_none")]
211    pub regex_flags: Option<String>,
212    #[serde(rename = "urlPattern", default, skip_serializing_if = "Option::is_none")]
213    pub url_pattern: Option<URLPattern>,
214}
215
216/// Parameters of `BrowserContext.setWebSocketInterceptionPatterns` (Route WebSockets).
217#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
218pub struct BrowserContextSetWebSocketInterceptionPatternsParams {
219    #[serde(rename = "patterns")]
220    pub patterns: Vec<BrowserContextSetWebSocketInterceptionPatternsParamsPatterns>,
221}
222
223/// Parameters of `BrowserContext.setOffline` (Set offline mode).
224#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
225pub struct BrowserContextSetOfflineParams {
226    #[serde(rename = "offline")]
227    pub offline: bool,
228}
229
230/// Parameters of `BrowserContext.storageState` (Get storage state).
231#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
232pub struct BrowserContextStorageStateParams {
233    #[serde(rename = "indexedDB", default, skip_serializing_if = "Option::is_none")]
234    pub indexed_db: Option<bool>,
235    #[serde(rename = "credentials", default, skip_serializing_if = "Option::is_none")]
236    pub credentials: Option<bool>,
237}
238
239/// Result of `BrowserContext.storageState` (Get storage state).
240#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
241pub struct BrowserContextStorageStateResult {
242    #[serde(rename = "cookies")]
243    pub cookies: Vec<NetworkCookie>,
244    #[serde(rename = "origins")]
245    pub origins: Vec<OriginStorage>,
246    #[serde(rename = "credentials", default, skip_serializing_if = "Option::is_none")]
247    pub credentials: Option<Vec<VirtualCredential>>,
248}
249
250#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
251pub struct BrowserContextSetStorageStateParamsStorageState {
252    #[serde(rename = "cookies", default, skip_serializing_if = "Option::is_none")]
253    pub cookies: Option<Vec<SetNetworkCookie>>,
254    #[serde(rename = "origins", default, skip_serializing_if = "Option::is_none")]
255    pub origins: Option<Vec<SetOriginStorage>>,
256    #[serde(rename = "credentials", default, skip_serializing_if = "Option::is_none")]
257    pub credentials: Option<Vec<VirtualCredential>>,
258}
259
260/// Parameters of `BrowserContext.setStorageState` (Set storage state).
261#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
262pub struct BrowserContextSetStorageStateParams {
263    #[serde(rename = "storageState", default, skip_serializing_if = "Option::is_none")]
264    pub storage_state: Option<BrowserContextSetStorageStateParamsStorageState>,
265}
266
267#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
268pub enum BrowserContextEnableRecorderParamsMode {
269    #[default]
270    #[serde(rename = "inspecting")]
271    Inspecting,
272    #[serde(rename = "recording")]
273    Recording,
274}
275
276#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
277pub enum BrowserContextEnableRecorderParamsRecorderMode {
278    #[default]
279    #[serde(rename = "default")]
280    Default,
281    #[serde(rename = "api")]
282    Api,
283}
284
285/// Parameters of `BrowserContext.enableRecorder`.
286#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
287pub struct BrowserContextEnableRecorderParams {
288    #[serde(rename = "language", default, skip_serializing_if = "Option::is_none")]
289    pub language: Option<String>,
290    #[serde(rename = "mode", default, skip_serializing_if = "Option::is_none")]
291    pub mode: Option<BrowserContextEnableRecorderParamsMode>,
292    #[serde(rename = "recorderMode", default, skip_serializing_if = "Option::is_none")]
293    pub recorder_mode: Option<BrowserContextEnableRecorderParamsRecorderMode>,
294    #[serde(rename = "pauseOnNextStatement", default, skip_serializing_if = "Option::is_none")]
295    pub pause_on_next_statement: Option<bool>,
296    #[serde(rename = "testIdAttributeName", default, skip_serializing_if = "Option::is_none")]
297    pub test_id_attribute_name: Option<String>,
298    #[serde(rename = "launchOptions", default, skip_serializing_if = "Option::is_none")]
299    pub launch_options: Option<serde_json::Value>,
300    #[serde(rename = "contextOptions", default, skip_serializing_if = "Option::is_none")]
301    pub context_options: Option<serde_json::Value>,
302    #[serde(rename = "device", default, skip_serializing_if = "Option::is_none")]
303    pub device: Option<String>,
304    #[serde(rename = "saveStorage", default, skip_serializing_if = "Option::is_none")]
305    pub save_storage: Option<String>,
306    #[serde(rename = "outputFile", default, skip_serializing_if = "Option::is_none")]
307    pub output_file: Option<String>,
308    #[serde(rename = "handleSIGINT", default, skip_serializing_if = "Option::is_none")]
309    pub handle_sigint: Option<bool>,
310    #[serde(rename = "omitCallTracking", default, skip_serializing_if = "Option::is_none")]
311    pub omit_call_tracking: Option<bool>,
312}
313
314/// Parameters of `BrowserContext.newCDPSession` (Create CDP session).
315#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
316pub struct BrowserContextNewCDPSessionParams {
317    #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
318    pub page: Option<Ref<Page>>,
319    #[serde(rename = "frame", default, skip_serializing_if = "Option::is_none")]
320    pub frame: Option<Ref<Frame>>,
321}
322
323/// Result of `BrowserContext.newCDPSession` (Create CDP session).
324#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
325pub struct BrowserContextNewCDPSessionResult {
326    #[serde(rename = "session")]
327    pub session: Ref<CDPSession>,
328}
329
330#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
331pub struct BrowserContextCreateTempFilesParamsItems {
332    #[serde(rename = "name")]
333    pub name: String,
334    #[serde(rename = "lastModifiedMs", default, skip_serializing_if = "Option::is_none")]
335    pub last_modified_ms: Option<f64>,
336}
337
338/// Parameters of `BrowserContext.createTempFiles`.
339#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
340pub struct BrowserContextCreateTempFilesParams {
341    #[serde(rename = "rootDirName", default, skip_serializing_if = "Option::is_none")]
342    pub root_dir_name: Option<String>,
343    #[serde(rename = "items")]
344    pub items: Vec<BrowserContextCreateTempFilesParamsItems>,
345}
346
347/// Result of `BrowserContext.createTempFiles`.
348#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
349pub struct BrowserContextCreateTempFilesResult {
350    #[serde(rename = "rootDir", default, skip_serializing_if = "Option::is_none")]
351    pub root_dir: Option<Ref<WritableStream>>,
352    #[serde(rename = "writableStreams")]
353    pub writable_streams: Vec<Ref<WritableStream>>,
354}
355
356#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
357pub enum BrowserContextUpdateSubscriptionParamsEvent {
358    #[default]
359    #[serde(rename = "console")]
360    Console,
361    #[serde(rename = "dialog")]
362    Dialog,
363    #[serde(rename = "request")]
364    Request,
365    #[serde(rename = "response")]
366    Response,
367    #[serde(rename = "requestFinished")]
368    RequestFinished,
369    #[serde(rename = "requestFailed")]
370    RequestFailed,
371}
372
373/// Parameters of `BrowserContext.updateSubscription`.
374#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
375pub struct BrowserContextUpdateSubscriptionParams {
376    #[serde(rename = "event")]
377    pub event: BrowserContextUpdateSubscriptionParamsEvent,
378    #[serde(rename = "enabled")]
379    pub enabled: bool,
380}
381
382/// Parameters of `BrowserContext.clockFastForward` (Fast forward clock "{ticksNumber|ticksString}").
383#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
384pub struct BrowserContextClockFastForwardParams {
385    #[serde(rename = "ticksNumber", default, skip_serializing_if = "Option::is_none")]
386    pub ticks_number: Option<f64>,
387    #[serde(rename = "ticksString", default, skip_serializing_if = "Option::is_none")]
388    pub ticks_string: Option<String>,
389}
390
391/// Parameters of `BrowserContext.clockInstall` (Install clock "{timeNumber|timeString}").
392#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
393pub struct BrowserContextClockInstallParams {
394    #[serde(rename = "timeNumber", default, skip_serializing_if = "Option::is_none")]
395    pub time_number: Option<f64>,
396    #[serde(rename = "timeString", default, skip_serializing_if = "Option::is_none")]
397    pub time_string: Option<String>,
398}
399
400/// Parameters of `BrowserContext.clockPauseAt` (Pause clock "{timeNumber|timeString}").
401#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
402pub struct BrowserContextClockPauseAtParams {
403    #[serde(rename = "timeNumber", default, skip_serializing_if = "Option::is_none")]
404    pub time_number: Option<f64>,
405    #[serde(rename = "timeString", default, skip_serializing_if = "Option::is_none")]
406    pub time_string: Option<String>,
407}
408
409/// Parameters of `BrowserContext.clockRunFor` (Run clock "{ticksNumber|ticksString}").
410#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
411pub struct BrowserContextClockRunForParams {
412    #[serde(rename = "ticksNumber", default, skip_serializing_if = "Option::is_none")]
413    pub ticks_number: Option<f64>,
414    #[serde(rename = "ticksString", default, skip_serializing_if = "Option::is_none")]
415    pub ticks_string: Option<String>,
416}
417
418/// Parameters of `BrowserContext.clockSetFixedTime` (Set fixed time "{timeNumber|timeString}").
419#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
420pub struct BrowserContextClockSetFixedTimeParams {
421    #[serde(rename = "timeNumber", default, skip_serializing_if = "Option::is_none")]
422    pub time_number: Option<f64>,
423    #[serde(rename = "timeString", default, skip_serializing_if = "Option::is_none")]
424    pub time_string: Option<String>,
425}
426
427/// Parameters of `BrowserContext.clockSetSystemTime` (Set system time "{timeNumber|timeString}").
428#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
429pub struct BrowserContextClockSetSystemTimeParams {
430    #[serde(rename = "timeNumber", default, skip_serializing_if = "Option::is_none")]
431    pub time_number: Option<f64>,
432    #[serde(rename = "timeString", default, skip_serializing_if = "Option::is_none")]
433    pub time_string: Option<String>,
434}
435
436/// Parameters of `BrowserContext.credentialsCreate` (Create virtual credential for "{rpId}").
437#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
438pub struct BrowserContextCredentialsCreateParams {
439    #[serde(rename = "rpId")]
440    pub rp_id: String,
441    #[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
442    pub id: Option<String>,
443    #[serde(rename = "userHandle", default, skip_serializing_if = "Option::is_none")]
444    pub user_handle: Option<String>,
445    #[serde(rename = "privateKey", default, skip_serializing_if = "Option::is_none")]
446    pub private_key: Option<String>,
447    #[serde(rename = "publicKey", default, skip_serializing_if = "Option::is_none")]
448    pub public_key: Option<String>,
449}
450
451/// Result of `BrowserContext.credentialsCreate` (Create virtual credential for "{rpId}").
452#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
453pub struct BrowserContextCredentialsCreateResult {
454    #[serde(rename = "credential")]
455    pub credential: VirtualCredential,
456}
457
458/// Parameters of `BrowserContext.credentialsGet` (Get virtual credentials).
459#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
460pub struct BrowserContextCredentialsGetParams {
461    #[serde(rename = "rpId", default, skip_serializing_if = "Option::is_none")]
462    pub rp_id: Option<String>,
463    #[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
464    pub id: Option<String>,
465}
466
467/// Result of `BrowserContext.credentialsGet` (Get virtual credentials).
468#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
469pub struct BrowserContextCredentialsGetResult {
470    #[serde(rename = "credentials")]
471    pub credentials: Vec<VirtualCredential>,
472}
473
474/// Parameters of `BrowserContext.credentialsDelete` (Delete virtual credential).
475#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
476pub struct BrowserContextCredentialsDeleteParams {
477    #[serde(rename = "id")]
478    pub id: String,
479}
480
481/// Payload of the `BrowserContext.bindingCall` event.
482#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
483pub struct BrowserContextBindingCallEventParams {
484    #[serde(rename = "binding")]
485    pub binding: Ref<BindingCall>,
486}
487
488/// Payload of the `BrowserContext.console` event.
489#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
490pub struct BrowserContextConsoleEventParams {
491    /// Properties of the `ConsoleMessage` mixin.
492    #[serde(flatten)]
493    pub console_message: ConsoleMessage,
494    #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
495    pub page: Option<Ref<Page>>,
496    #[serde(rename = "worker", default, skip_serializing_if = "Option::is_none")]
497    pub worker: Option<Ref<Worker>>,
498}
499
500/// Payload of the `BrowserContext.dialog` event.
501#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
502pub struct BrowserContextDialogEventParams {
503    #[serde(rename = "dialog")]
504    pub dialog: Ref<Dialog>,
505}
506
507/// Payload of the `BrowserContext.page` event.
508#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
509pub struct BrowserContextPageEventParams {
510    #[serde(rename = "page")]
511    pub page: Ref<Page>,
512}
513
514#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
515pub struct BrowserContextPageErrorEventParamsLocation {
516    #[serde(rename = "url")]
517    pub url: String,
518    #[serde(rename = "line")]
519    pub line: i64,
520    #[serde(rename = "column")]
521    pub column: i64,
522}
523
524/// Payload of the `BrowserContext.pageError` event.
525#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
526pub struct BrowserContextPageErrorEventParams {
527    #[serde(rename = "error")]
528    pub error: SerializedError,
529    #[serde(rename = "page")]
530    pub page: Ref<Page>,
531    #[serde(rename = "location")]
532    pub location: BrowserContextPageErrorEventParamsLocation,
533}
534
535/// Payload of the `BrowserContext.route` event.
536#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
537pub struct BrowserContextRouteEventParams {
538    #[serde(rename = "route")]
539    pub route: Ref<Route>,
540}
541
542/// Payload of the `BrowserContext.webSocketRoute` event.
543#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
544pub struct BrowserContextWebSocketRouteEventParams {
545    #[serde(rename = "webSocketRoute")]
546    pub web_socket_route: Ref<WebSocketRoute>,
547}
548
549/// Payload of the `BrowserContext.serviceWorker` event.
550#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
551pub struct BrowserContextServiceWorkerEventParams {
552    #[serde(rename = "worker")]
553    pub worker: Ref<Worker>,
554}
555
556/// Payload of the `BrowserContext.request` event.
557#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
558pub struct BrowserContextRequestEventParams {
559    #[serde(rename = "request")]
560    pub request: Ref<Request>,
561    #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
562    pub page: Option<Ref<Page>>,
563}
564
565/// Payload of the `BrowserContext.requestFailed` event.
566#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
567pub struct BrowserContextRequestFailedEventParams {
568    #[serde(rename = "request")]
569    pub request: Ref<Request>,
570    #[serde(rename = "failureText", default, skip_serializing_if = "Option::is_none")]
571    pub failure_text: Option<String>,
572    #[serde(rename = "responseEndTiming")]
573    pub response_end_timing: f64,
574    #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
575    pub page: Option<Ref<Page>>,
576}
577
578/// Payload of the `BrowserContext.requestFinished` event.
579#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
580pub struct BrowserContextRequestFinishedEventParams {
581    #[serde(rename = "request")]
582    pub request: Ref<Request>,
583    #[serde(rename = "response", default, skip_serializing_if = "Option::is_none")]
584    pub response: Option<Ref<Response>>,
585    #[serde(rename = "responseEndTiming")]
586    pub response_end_timing: f64,
587    #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
588    pub page: Option<Ref<Page>>,
589}
590
591/// Payload of the `BrowserContext.response` event.
592#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
593pub struct BrowserContextResponseEventParams {
594    #[serde(rename = "response")]
595    pub response: Ref<Response>,
596    #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
597    pub page: Option<Ref<Page>>,
598}
599
600#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
601pub enum BrowserContextRecorderEventEventParamsEvent {
602    #[default]
603    #[serde(rename = "actionAdded")]
604    ActionAdded,
605    #[serde(rename = "actionUpdated")]
606    ActionUpdated,
607    #[serde(rename = "signalAdded")]
608    SignalAdded,
609}
610
611/// Payload of the `BrowserContext.recorderEvent` event.
612#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
613pub struct BrowserContextRecorderEventEventParams {
614    #[serde(rename = "event")]
615    pub event: BrowserContextRecorderEventEventParamsEvent,
616    #[serde(rename = "data")]
617    pub data: serde_json::Value,
618    #[serde(rename = "page")]
619    pub page: Ref<Page>,
620    #[serde(rename = "code")]
621    pub code: String,
622}
623
624/// Events a `BrowserContext` channel can emit.
625#[derive(Debug, Clone, PartialEq)]
626pub enum BrowserContextEvent {
627    /// `BrowserContext.bindingCall`
628    BindingCall(BrowserContextBindingCallEventParams),
629    /// `BrowserContext.console`
630    Console(BrowserContextConsoleEventParams),
631    /// `BrowserContext.close`
632    Close,
633    /// `BrowserContext.dialog`
634    Dialog(BrowserContextDialogEventParams),
635    /// `BrowserContext.page`
636    Page(BrowserContextPageEventParams),
637    /// `BrowserContext.pageError`
638    PageError(BrowserContextPageErrorEventParams),
639    /// `BrowserContext.route`
640    Route(BrowserContextRouteEventParams),
641    /// `BrowserContext.webSocketRoute`
642    WebSocketRoute(BrowserContextWebSocketRouteEventParams),
643    /// `BrowserContext.serviceWorker`
644    ServiceWorker(BrowserContextServiceWorkerEventParams),
645    /// `BrowserContext.request`
646    Request(BrowserContextRequestEventParams),
647    /// `BrowserContext.requestFailed`
648    RequestFailed(BrowserContextRequestFailedEventParams),
649    /// `BrowserContext.requestFinished`
650    RequestFinished(BrowserContextRequestFinishedEventParams),
651    /// `BrowserContext.response`
652    Response(BrowserContextResponseEventParams),
653    /// `BrowserContext.recorderEvent`
654    RecorderEvent(BrowserContextRecorderEventEventParams),
655    /// An event this binding does not know (a newer driver).
656    Unknown {
657        /// Event name.
658        method: String,
659        /// Raw event parameters.
660        params: serde_json::Value,
661    },
662}
663
664impl ProtocolEvent for BrowserContextEvent {
665    fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
666        match method {
667            "bindingCall" => Ok(Self::BindingCall(serde_json::from_value(params)?)),
668            "console" => Ok(Self::Console(serde_json::from_value(params)?)),
669            "close" => Ok(Self::Close),
670            "dialog" => Ok(Self::Dialog(serde_json::from_value(params)?)),
671            "page" => Ok(Self::Page(serde_json::from_value(params)?)),
672            "pageError" => Ok(Self::PageError(serde_json::from_value(params)?)),
673            "route" => Ok(Self::Route(serde_json::from_value(params)?)),
674            "webSocketRoute" => Ok(Self::WebSocketRoute(serde_json::from_value(params)?)),
675            "serviceWorker" => Ok(Self::ServiceWorker(serde_json::from_value(params)?)),
676            "request" => Ok(Self::Request(serde_json::from_value(params)?)),
677            "requestFailed" => Ok(Self::RequestFailed(serde_json::from_value(params)?)),
678            "requestFinished" => Ok(Self::RequestFinished(serde_json::from_value(params)?)),
679            "response" => Ok(Self::Response(serde_json::from_value(params)?)),
680            "recorderEvent" => Ok(Self::RecorderEvent(serde_json::from_value(params)?)),
681            _ => Ok(Self::Unknown { method: method.to_string(), params }),
682        }
683    }
684}
685
686/// Channel for the `BrowserContext` interface (`browserContext.yml`).
687#[derive(Debug, Clone)]
688pub struct BrowserContext {
689    channel: Channel,
690}
691
692impl ChannelType for BrowserContext {
693    const INTERFACE: &'static str = "BrowserContext";
694    type Initializer = BrowserContextInitializer;
695    type Event = BrowserContextEvent;
696
697    fn accepts(interface: &str) -> bool {
698        matches!(interface, "BrowserContext")
699    }
700
701    fn from_channel(channel: Channel) -> Self {
702        Self { channel }
703    }
704
705    fn channel(&self) -> &Channel {
706        &self.channel
707    }
708}
709
710impl BrowserContext {
711    /// `BrowserContext.addCookies` ("Add cookies").
712    pub async fn add_cookies(&self, params: BrowserContextAddCookiesParams) -> Result<(), ProtocolError> {
713        self.channel.send_no_result("addCookies", &params).await
714    }
715
716    /// `BrowserContext.addInitScript` ("Add init script").
717    pub async fn add_init_script(&self, params: BrowserContextAddInitScriptParams) -> Result<BrowserContextAddInitScriptResult, ProtocolError> {
718        self.channel.send("addInitScript", &params).await
719    }
720
721    /// `BrowserContext.clearCookies` ("Clear cookies").
722    pub async fn clear_cookies(&self, params: BrowserContextClearCookiesParams) -> Result<(), ProtocolError> {
723        self.channel.send_no_result("clearCookies", &params).await
724    }
725
726    /// `BrowserContext.clearPermissions` ("Clear permissions").
727    pub async fn clear_permissions(&self) -> Result<(), ProtocolError> {
728        self.channel.send_no_result("clearPermissions", &serde_json::json!({})).await
729    }
730
731    /// `BrowserContext.close` ("Close context").
732    pub async fn close(&self, params: BrowserContextCloseParams) -> Result<(), ProtocolError> {
733        self.channel.send_no_result("close", &params).await
734    }
735
736    /// `BrowserContext.cookies` ("Get cookies").
737    pub async fn cookies(&self, params: BrowserContextCookiesParams) -> Result<BrowserContextCookiesResult, ProtocolError> {
738        self.channel.send("cookies", &params).await
739    }
740
741    /// `BrowserContext.exposeBinding` ("Expose binding").
742    pub async fn expose_binding(&self, params: BrowserContextExposeBindingParams) -> Result<BrowserContextExposeBindingResult, ProtocolError> {
743        self.channel.send("exposeBinding", &params).await
744    }
745
746    /// `BrowserContext.grantPermissions` ("Grant permissions").
747    pub async fn grant_permissions(&self, params: BrowserContextGrantPermissionsParams) -> Result<(), ProtocolError> {
748        self.channel.send_no_result("grantPermissions", &params).await
749    }
750
751    /// `BrowserContext.newPage` ("Create page").
752    pub async fn new_page(&self) -> Result<BrowserContextNewPageResult, ProtocolError> {
753        self.channel.send("newPage", &serde_json::json!({})).await
754    }
755
756    /// `BrowserContext.registerSelectorEngine` (internal).
757    pub async fn register_selector_engine(&self, params: BrowserContextRegisterSelectorEngineParams) -> Result<(), ProtocolError> {
758        self.channel.send_no_result("registerSelectorEngine", &params).await
759    }
760
761    /// `BrowserContext.setTestIdAttributeName` (internal).
762    pub async fn set_test_id_attribute_name(&self, params: BrowserContextSetTestIdAttributeNameParams) -> Result<(), ProtocolError> {
763        self.channel.send_no_result("setTestIdAttributeName", &params).await
764    }
765
766    /// `BrowserContext.setExtraHTTPHeaders` ("Set extra HTTP headers").
767    pub async fn set_extra_http_headers(&self, params: BrowserContextSetExtraHTTPHeadersParams) -> Result<(), ProtocolError> {
768        self.channel.send_no_result("setExtraHTTPHeaders", &params).await
769    }
770
771    /// `BrowserContext.setGeolocation` ("Set geolocation").
772    pub async fn set_geolocation(&self, params: BrowserContextSetGeolocationParams) -> Result<(), ProtocolError> {
773        self.channel.send_no_result("setGeolocation", &params).await
774    }
775
776    /// `BrowserContext.setHTTPCredentials` ("Set HTTP credentials").
777    pub async fn set_http_credentials(&self, params: BrowserContextSetHTTPCredentialsParams) -> Result<(), ProtocolError> {
778        self.channel.send_no_result("setHTTPCredentials", &params).await
779    }
780
781    /// `BrowserContext.setNetworkInterceptionPatterns` ("Route requests").
782    pub async fn set_network_interception_patterns(&self, params: BrowserContextSetNetworkInterceptionPatternsParams) -> Result<(), ProtocolError> {
783        self.channel.send_no_result("setNetworkInterceptionPatterns", &params).await
784    }
785
786    /// `BrowserContext.setWebSocketInterceptionPatterns` ("Route WebSockets").
787    pub async fn set_web_socket_interception_patterns(&self, params: BrowserContextSetWebSocketInterceptionPatternsParams) -> Result<(), ProtocolError> {
788        self.channel.send_no_result("setWebSocketInterceptionPatterns", &params).await
789    }
790
791    /// `BrowserContext.setOffline` ("Set offline mode").
792    pub async fn set_offline(&self, params: BrowserContextSetOfflineParams) -> Result<(), ProtocolError> {
793        self.channel.send_no_result("setOffline", &params).await
794    }
795
796    /// `BrowserContext.storageState` ("Get storage state").
797    pub async fn storage_state(&self, params: BrowserContextStorageStateParams) -> Result<BrowserContextStorageStateResult, ProtocolError> {
798        self.channel.send("storageState", &params).await
799    }
800
801    /// `BrowserContext.setStorageState` ("Set storage state").
802    pub async fn set_storage_state(&self, params: BrowserContextSetStorageStateParams) -> Result<(), ProtocolError> {
803        self.channel.send_no_result("setStorageState", &params).await
804    }
805
806    /// `BrowserContext.pause` ("Pause").
807    pub async fn pause(&self) -> Result<(), ProtocolError> {
808        self.channel.send_no_result("pause", &serde_json::json!({})).await
809    }
810
811    /// `BrowserContext.enableRecorder` (internal).
812    pub async fn enable_recorder(&self, params: BrowserContextEnableRecorderParams) -> Result<(), ProtocolError> {
813        self.channel.send_no_result("enableRecorder", &params).await
814    }
815
816    /// `BrowserContext.disableRecorder` (internal).
817    pub async fn disable_recorder(&self) -> Result<(), ProtocolError> {
818        self.channel.send_no_result("disableRecorder", &serde_json::json!({})).await
819    }
820
821    /// `BrowserContext.exposeConsoleApi` (internal).
822    pub async fn expose_console_api(&self) -> Result<(), ProtocolError> {
823        self.channel.send_no_result("exposeConsoleApi", &serde_json::json!({})).await
824    }
825
826    /// `BrowserContext.newCDPSession` ("Create CDP session").
827    pub async fn new_cdp_session(&self, params: BrowserContextNewCDPSessionParams) -> Result<BrowserContextNewCDPSessionResult, ProtocolError> {
828        self.channel.send("newCDPSession", &params).await
829    }
830
831    /// `BrowserContext.createTempFiles` (internal).
832    pub async fn create_temp_files(&self, params: BrowserContextCreateTempFilesParams) -> Result<BrowserContextCreateTempFilesResult, ProtocolError> {
833        self.channel.send("createTempFiles", &params).await
834    }
835
836    /// `BrowserContext.updateSubscription` (internal).
837    pub async fn update_subscription(&self, params: BrowserContextUpdateSubscriptionParams) -> Result<(), ProtocolError> {
838        self.channel.send_no_result("updateSubscription", &params).await
839    }
840
841    /// `BrowserContext.clockFastForward` ("Fast forward clock "{ticksNumber|ticksString}"").
842    pub async fn clock_fast_forward(&self, params: BrowserContextClockFastForwardParams) -> Result<(), ProtocolError> {
843        self.channel.send_no_result("clockFastForward", &params).await
844    }
845
846    /// `BrowserContext.clockInstall` ("Install clock "{timeNumber|timeString}"").
847    pub async fn clock_install(&self, params: BrowserContextClockInstallParams) -> Result<(), ProtocolError> {
848        self.channel.send_no_result("clockInstall", &params).await
849    }
850
851    /// `BrowserContext.clockPauseAt` ("Pause clock "{timeNumber|timeString}"").
852    pub async fn clock_pause_at(&self, params: BrowserContextClockPauseAtParams) -> Result<(), ProtocolError> {
853        self.channel.send_no_result("clockPauseAt", &params).await
854    }
855
856    /// `BrowserContext.clockResume` ("Resume clock").
857    pub async fn clock_resume(&self) -> Result<(), ProtocolError> {
858        self.channel.send_no_result("clockResume", &serde_json::json!({})).await
859    }
860
861    /// `BrowserContext.clockRunFor` ("Run clock "{ticksNumber|ticksString}"").
862    pub async fn clock_run_for(&self, params: BrowserContextClockRunForParams) -> Result<(), ProtocolError> {
863        self.channel.send_no_result("clockRunFor", &params).await
864    }
865
866    /// `BrowserContext.clockSetFixedTime` ("Set fixed time "{timeNumber|timeString}"").
867    pub async fn clock_set_fixed_time(&self, params: BrowserContextClockSetFixedTimeParams) -> Result<(), ProtocolError> {
868        self.channel.send_no_result("clockSetFixedTime", &params).await
869    }
870
871    /// `BrowserContext.clockSetSystemTime` ("Set system time "{timeNumber|timeString}"").
872    pub async fn clock_set_system_time(&self, params: BrowserContextClockSetSystemTimeParams) -> Result<(), ProtocolError> {
873        self.channel.send_no_result("clockSetSystemTime", &params).await
874    }
875
876    /// `BrowserContext.credentialsInstall` ("Install virtual WebAuthn authenticator").
877    pub async fn credentials_install(&self) -> Result<(), ProtocolError> {
878        self.channel.send_no_result("credentialsInstall", &serde_json::json!({})).await
879    }
880
881    /// `BrowserContext.credentialsCreate` ("Create virtual credential for "{rpId}"").
882    pub async fn credentials_create(&self, params: BrowserContextCredentialsCreateParams) -> Result<BrowserContextCredentialsCreateResult, ProtocolError> {
883        self.channel.send("credentialsCreate", &params).await
884    }
885
886    /// `BrowserContext.credentialsGet` ("Get virtual credentials").
887    pub async fn credentials_get(&self, params: BrowserContextCredentialsGetParams) -> Result<BrowserContextCredentialsGetResult, ProtocolError> {
888        self.channel.send("credentialsGet", &params).await
889    }
890
891    /// `BrowserContext.credentialsDelete` ("Delete virtual credential").
892    pub async fn credentials_delete(&self, params: BrowserContextCredentialsDeleteParams) -> Result<(), ProtocolError> {
893        self.channel.send_no_result("credentialsDelete", &params).await
894    }
895}