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 BrowserContextInitializerOptions {
15 #[serde(flatten)]
17 pub context_options: ContextOptions,
18}
19
20#[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#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
35pub struct BrowserContextAddCookiesParams {
36 #[serde(rename = "cookies")]
37 pub cookies: Vec<SetNetworkCookie>,
38}
39
40#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
42pub struct BrowserContextAddInitScriptParams {
43 #[serde(rename = "source")]
44 pub source: String,
45}
46
47#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
49pub struct BrowserContextAddInitScriptResult {
50 #[serde(rename = "disposable")]
51 pub disposable: Ref<Disposable>,
52}
53
54#[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#[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#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
86pub struct BrowserContextCookiesParams {
87 #[serde(rename = "urls")]
88 pub urls: Vec<String>,
89}
90
91#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
93pub struct BrowserContextCookiesResult {
94 #[serde(rename = "cookies")]
95 pub cookies: Vec<NetworkCookie>,
96}
97
98#[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#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
109pub struct BrowserContextExposeBindingResult {
110 #[serde(rename = "disposable")]
111 pub disposable: Ref<Disposable>,
112}
113
114#[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#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
125pub struct BrowserContextNewPageResult {
126 #[serde(rename = "page")]
127 pub page: Ref<Page>,
128}
129
130#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
132pub struct BrowserContextRegisterSelectorEngineParams {
133 #[serde(rename = "selectorEngine")]
134 pub selector_engine: SelectorEngine,
135}
136
137#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
139pub struct BrowserContextSetTestIdAttributeNameParams {
140 #[serde(rename = "testIdAttributeName")]
141 pub test_id_attribute_name: String,
142}
143
144#[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#[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)]
170pub struct BrowserContextSetHTTPCredentialsParams {
171 #[serde(rename = "httpCredentials", default, skip_serializing_if = "Option::is_none")]
172 pub http_credentials: Option<Vec<HttpCredentials>>,
173}
174
175#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
176pub struct BrowserContextSetNetworkInterceptionPatternsParamsPatterns {
177 #[serde(rename = "glob", default, skip_serializing_if = "Option::is_none")]
178 pub glob: Option<String>,
179 #[serde(rename = "regexSource", default, skip_serializing_if = "Option::is_none")]
180 pub regex_source: Option<String>,
181 #[serde(rename = "regexFlags", default, skip_serializing_if = "Option::is_none")]
182 pub regex_flags: Option<String>,
183 #[serde(rename = "urlPattern", default, skip_serializing_if = "Option::is_none")]
184 pub url_pattern: Option<URLPattern>,
185}
186
187#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
189pub struct BrowserContextSetNetworkInterceptionPatternsParams {
190 #[serde(rename = "patterns")]
191 pub patterns: Vec<BrowserContextSetNetworkInterceptionPatternsParamsPatterns>,
192}
193
194#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
195pub struct BrowserContextSetWebSocketInterceptionPatternsParamsPatterns {
196 #[serde(rename = "glob", default, skip_serializing_if = "Option::is_none")]
197 pub glob: Option<String>,
198 #[serde(rename = "regexSource", default, skip_serializing_if = "Option::is_none")]
199 pub regex_source: Option<String>,
200 #[serde(rename = "regexFlags", default, skip_serializing_if = "Option::is_none")]
201 pub regex_flags: Option<String>,
202 #[serde(rename = "urlPattern", default, skip_serializing_if = "Option::is_none")]
203 pub url_pattern: Option<URLPattern>,
204}
205
206#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
208pub struct BrowserContextSetWebSocketInterceptionPatternsParams {
209 #[serde(rename = "patterns")]
210 pub patterns: Vec<BrowserContextSetWebSocketInterceptionPatternsParamsPatterns>,
211}
212
213#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
215pub struct BrowserContextSetOfflineParams {
216 #[serde(rename = "offline")]
217 pub offline: bool,
218}
219
220#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
222pub struct BrowserContextStorageStateParams {
223 #[serde(rename = "indexedDB", default, skip_serializing_if = "Option::is_none")]
224 pub indexed_db: Option<bool>,
225 #[serde(rename = "opfs", default, skip_serializing_if = "Option::is_none")]
226 pub opfs: Option<bool>,
227 #[serde(rename = "credentials", default, skip_serializing_if = "Option::is_none")]
228 pub credentials: Option<bool>,
229}
230
231#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
233pub struct BrowserContextStorageStateResult {
234 #[serde(rename = "cookies")]
235 pub cookies: Vec<NetworkCookie>,
236 #[serde(rename = "origins")]
237 pub origins: Vec<OriginStorage>,
238 #[serde(rename = "credentials", default, skip_serializing_if = "Option::is_none")]
239 pub credentials: Option<Vec<VirtualCredential>>,
240}
241
242#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
243pub struct BrowserContextSetStorageStateParamsStorageState {
244 #[serde(rename = "cookies", default, skip_serializing_if = "Option::is_none")]
245 pub cookies: Option<Vec<SetNetworkCookie>>,
246 #[serde(rename = "origins", default, skip_serializing_if = "Option::is_none")]
247 pub origins: Option<Vec<SetOriginStorage>>,
248 #[serde(rename = "credentials", default, skip_serializing_if = "Option::is_none")]
249 pub credentials: Option<Vec<VirtualCredential>>,
250}
251
252#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
254pub struct BrowserContextSetStorageStateParams {
255 #[serde(rename = "storageState", default, skip_serializing_if = "Option::is_none")]
256 pub storage_state: Option<BrowserContextSetStorageStateParamsStorageState>,
257}
258
259#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
260pub enum BrowserContextEnableRecorderParamsMode {
261 #[default]
262 #[serde(rename = "inspecting")]
263 Inspecting,
264 #[serde(rename = "recording")]
265 Recording,
266}
267
268#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
269pub enum BrowserContextEnableRecorderParamsRecorderMode {
270 #[default]
271 #[serde(rename = "default")]
272 Default,
273 #[serde(rename = "api")]
274 Api,
275}
276
277#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
279pub struct BrowserContextEnableRecorderParams {
280 #[serde(rename = "language", default, skip_serializing_if = "Option::is_none")]
281 pub language: Option<String>,
282 #[serde(rename = "mode", default, skip_serializing_if = "Option::is_none")]
283 pub mode: Option<BrowserContextEnableRecorderParamsMode>,
284 #[serde(rename = "recorderMode", default, skip_serializing_if = "Option::is_none")]
285 pub recorder_mode: Option<BrowserContextEnableRecorderParamsRecorderMode>,
286 #[serde(rename = "pauseOnNextStatement", default, skip_serializing_if = "Option::is_none")]
287 pub pause_on_next_statement: Option<bool>,
288 #[serde(rename = "testIdAttributeName", default, skip_serializing_if = "Option::is_none")]
289 pub test_id_attribute_name: Option<String>,
290 #[serde(rename = "launchOptions", default, skip_serializing_if = "Option::is_none")]
291 pub launch_options: Option<serde_json::Value>,
292 #[serde(rename = "contextOptions", default, skip_serializing_if = "Option::is_none")]
293 pub context_options: Option<serde_json::Value>,
294 #[serde(rename = "device", default, skip_serializing_if = "Option::is_none")]
295 pub device: Option<String>,
296 #[serde(rename = "saveStorage", default, skip_serializing_if = "Option::is_none")]
297 pub save_storage: Option<String>,
298 #[serde(rename = "outputFile", default, skip_serializing_if = "Option::is_none")]
299 pub output_file: Option<String>,
300 #[serde(rename = "handleSIGINT", default, skip_serializing_if = "Option::is_none")]
301 pub handle_sigint: Option<bool>,
302 #[serde(rename = "omitCallTracking", default, skip_serializing_if = "Option::is_none")]
303 pub omit_call_tracking: Option<bool>,
304}
305
306#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
308pub struct BrowserContextNewCDPSessionParams {
309 #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
310 pub page: Option<Ref<Page>>,
311 #[serde(rename = "frame", default, skip_serializing_if = "Option::is_none")]
312 pub frame: Option<Ref<Frame>>,
313}
314
315#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
317pub struct BrowserContextNewCDPSessionResult {
318 #[serde(rename = "session")]
319 pub session: Ref<CDPSession>,
320}
321
322#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
323pub struct BrowserContextCreateTempFilesParamsItems {
324 #[serde(rename = "name")]
325 pub name: String,
326 #[serde(rename = "lastModifiedMs", default, skip_serializing_if = "Option::is_none")]
327 pub last_modified_ms: Option<f64>,
328}
329
330#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
332pub struct BrowserContextCreateTempFilesParams {
333 #[serde(rename = "rootDirName", default, skip_serializing_if = "Option::is_none")]
334 pub root_dir_name: Option<String>,
335 #[serde(rename = "items")]
336 pub items: Vec<BrowserContextCreateTempFilesParamsItems>,
337}
338
339#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
341pub struct BrowserContextCreateTempFilesResult {
342 #[serde(rename = "rootDir", default, skip_serializing_if = "Option::is_none")]
343 pub root_dir: Option<Ref<WritableStream>>,
344 #[serde(rename = "writableStreams")]
345 pub writable_streams: Vec<Ref<WritableStream>>,
346}
347
348#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
349pub enum BrowserContextUpdateSubscriptionParamsEvent {
350 #[default]
351 #[serde(rename = "console")]
352 Console,
353 #[serde(rename = "dialog")]
354 Dialog,
355 #[serde(rename = "dialogClosed")]
356 DialogClosed,
357 #[serde(rename = "request")]
358 Request,
359 #[serde(rename = "response")]
360 Response,
361 #[serde(rename = "requestFinished")]
362 RequestFinished,
363 #[serde(rename = "requestFailed")]
364 RequestFailed,
365}
366
367#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
369pub struct BrowserContextUpdateSubscriptionParams {
370 #[serde(rename = "event")]
371 pub event: BrowserContextUpdateSubscriptionParamsEvent,
372 #[serde(rename = "enabled")]
373 pub enabled: bool,
374}
375
376#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
378pub struct BrowserContextClockFastForwardParams {
379 #[serde(rename = "ticksNumber", default, skip_serializing_if = "Option::is_none")]
380 pub ticks_number: Option<f64>,
381 #[serde(rename = "ticksString", default, skip_serializing_if = "Option::is_none")]
382 pub ticks_string: Option<String>,
383}
384
385#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
387pub struct BrowserContextClockInstallParams {
388 #[serde(rename = "timeNumber", default, skip_serializing_if = "Option::is_none")]
389 pub time_number: Option<f64>,
390 #[serde(rename = "timeString", default, skip_serializing_if = "Option::is_none")]
391 pub time_string: Option<String>,
392}
393
394#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
396pub struct BrowserContextClockPauseAtParams {
397 #[serde(rename = "timeNumber", default, skip_serializing_if = "Option::is_none")]
398 pub time_number: Option<f64>,
399 #[serde(rename = "timeString", default, skip_serializing_if = "Option::is_none")]
400 pub time_string: Option<String>,
401}
402
403#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
405pub struct BrowserContextClockRunForParams {
406 #[serde(rename = "ticksNumber", default, skip_serializing_if = "Option::is_none")]
407 pub ticks_number: Option<f64>,
408 #[serde(rename = "ticksString", default, skip_serializing_if = "Option::is_none")]
409 pub ticks_string: Option<String>,
410}
411
412#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
414pub struct BrowserContextClockSetFixedTimeParams {
415 #[serde(rename = "timeNumber", default, skip_serializing_if = "Option::is_none")]
416 pub time_number: Option<f64>,
417 #[serde(rename = "timeString", default, skip_serializing_if = "Option::is_none")]
418 pub time_string: Option<String>,
419}
420
421#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
423pub struct BrowserContextClockSetSystemTimeParams {
424 #[serde(rename = "timeNumber", default, skip_serializing_if = "Option::is_none")]
425 pub time_number: Option<f64>,
426 #[serde(rename = "timeString", default, skip_serializing_if = "Option::is_none")]
427 pub time_string: Option<String>,
428}
429
430#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
432pub struct BrowserContextCredentialsCreateParams {
433 #[serde(rename = "rpId")]
434 pub rp_id: String,
435 #[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
436 pub id: Option<String>,
437 #[serde(rename = "userHandle", default, skip_serializing_if = "Option::is_none")]
438 pub user_handle: Option<String>,
439 #[serde(rename = "privateKey", default, skip_serializing_if = "Option::is_none")]
440 pub private_key: Option<String>,
441 #[serde(rename = "publicKey", default, skip_serializing_if = "Option::is_none")]
442 pub public_key: Option<String>,
443}
444
445#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
447pub struct BrowserContextCredentialsCreateResult {
448 #[serde(rename = "credential")]
449 pub credential: VirtualCredential,
450}
451
452#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
454pub struct BrowserContextCredentialsGetParams {
455 #[serde(rename = "rpId", default, skip_serializing_if = "Option::is_none")]
456 pub rp_id: Option<String>,
457 #[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
458 pub id: Option<String>,
459}
460
461#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
463pub struct BrowserContextCredentialsGetResult {
464 #[serde(rename = "credentials")]
465 pub credentials: Vec<VirtualCredential>,
466}
467
468#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
470pub struct BrowserContextCredentialsDeleteParams {
471 #[serde(rename = "id")]
472 pub id: String,
473}
474
475#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
477pub struct BrowserContextBindingCallEventParams {
478 #[serde(rename = "binding")]
479 pub binding: Ref<BindingCall>,
480}
481
482#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
484pub struct BrowserContextConsoleEventParams {
485 #[serde(flatten)]
487 pub console_message: ConsoleMessage,
488 #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
489 pub page: Option<Ref<Page>>,
490 #[serde(rename = "worker", default, skip_serializing_if = "Option::is_none")]
491 pub worker: Option<Ref<Worker>>,
492}
493
494#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
496pub struct BrowserContextDialogEventParams {
497 #[serde(rename = "dialog")]
498 pub dialog: Ref<Dialog>,
499}
500
501#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
503pub struct BrowserContextDialogClosedEventParams {
504 #[serde(rename = "dialog")]
505 pub dialog: Ref<Dialog>,
506}
507
508#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
510pub struct BrowserContextPageEventParams {
511 #[serde(rename = "page")]
512 pub page: Ref<Page>,
513}
514
515#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
516pub struct BrowserContextPageErrorEventParamsLocation {
517 #[serde(rename = "url")]
518 pub url: String,
519 #[serde(rename = "line")]
520 pub line: i64,
521 #[serde(rename = "column")]
522 pub column: i64,
523}
524
525#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
527pub struct BrowserContextPageErrorEventParams {
528 #[serde(rename = "error")]
529 pub error: SerializedError,
530 #[serde(rename = "page")]
531 pub page: Ref<Page>,
532 #[serde(rename = "location")]
533 pub location: BrowserContextPageErrorEventParamsLocation,
534}
535
536#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
538pub struct BrowserContextRouteEventParams {
539 #[serde(rename = "route")]
540 pub route: Ref<Route>,
541}
542
543#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
545pub struct BrowserContextWebSocketRouteEventParams {
546 #[serde(rename = "webSocketRoute")]
547 pub web_socket_route: Ref<WebSocketRoute>,
548}
549
550#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
552pub struct BrowserContextServiceWorkerEventParams {
553 #[serde(rename = "worker")]
554 pub worker: Ref<Worker>,
555}
556
557#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
559pub struct BrowserContextRequestEventParams {
560 #[serde(rename = "request")]
561 pub request: Ref<Request>,
562 #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
563 pub page: Option<Ref<Page>>,
564}
565
566#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
568pub struct BrowserContextRequestFailedEventParams {
569 #[serde(rename = "request")]
570 pub request: Ref<Request>,
571 #[serde(rename = "failureText", default, skip_serializing_if = "Option::is_none")]
572 pub failure_text: Option<String>,
573 #[serde(rename = "responseEndTiming")]
574 pub response_end_timing: f64,
575 #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
576 pub page: Option<Ref<Page>>,
577}
578
579#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
581pub struct BrowserContextRequestFinishedEventParams {
582 #[serde(rename = "request")]
583 pub request: Ref<Request>,
584 #[serde(rename = "response", default, skip_serializing_if = "Option::is_none")]
585 pub response: Option<Ref<Response>>,
586 #[serde(rename = "responseEndTiming")]
587 pub response_end_timing: f64,
588 #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
589 pub page: Option<Ref<Page>>,
590}
591
592#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
594pub struct BrowserContextResponseEventParams {
595 #[serde(rename = "response")]
596 pub response: Ref<Response>,
597 #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
598 pub page: Option<Ref<Page>>,
599}
600
601#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
602pub enum BrowserContextRecorderEventEventParamsEvent {
603 #[default]
604 #[serde(rename = "actionAdded")]
605 ActionAdded,
606 #[serde(rename = "actionUpdated")]
607 ActionUpdated,
608 #[serde(rename = "signalAdded")]
609 SignalAdded,
610}
611
612#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
614pub struct BrowserContextRecorderEventEventParams {
615 #[serde(rename = "event")]
616 pub event: BrowserContextRecorderEventEventParamsEvent,
617 #[serde(rename = "data")]
618 pub data: serde_json::Value,
619 #[serde(rename = "page")]
620 pub page: Ref<Page>,
621 #[serde(rename = "code")]
622 pub code: String,
623}
624
625#[derive(Debug, Clone, PartialEq)]
627pub enum BrowserContextEvent {
628 BindingCall(BrowserContextBindingCallEventParams),
630 Console(BrowserContextConsoleEventParams),
632 Close,
634 Dialog(BrowserContextDialogEventParams),
636 DialogClosed(BrowserContextDialogClosedEventParams),
638 Page(BrowserContextPageEventParams),
640 PageError(BrowserContextPageErrorEventParams),
642 Route(BrowserContextRouteEventParams),
644 WebSocketRoute(BrowserContextWebSocketRouteEventParams),
646 ServiceWorker(BrowserContextServiceWorkerEventParams),
648 Request(BrowserContextRequestEventParams),
650 RequestFailed(BrowserContextRequestFailedEventParams),
652 RequestFinished(BrowserContextRequestFinishedEventParams),
654 Response(BrowserContextResponseEventParams),
656 RecorderEvent(BrowserContextRecorderEventEventParams),
658 Unknown {
660 method: String,
662 params: serde_json::Value,
664 },
665}
666
667impl ProtocolEvent for BrowserContextEvent {
668 fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
669 match method {
670 "bindingCall" => Ok(Self::BindingCall(serde_json::from_value(params)?)),
671 "console" => Ok(Self::Console(serde_json::from_value(params)?)),
672 "close" => Ok(Self::Close),
673 "dialog" => Ok(Self::Dialog(serde_json::from_value(params)?)),
674 "dialogClosed" => Ok(Self::DialogClosed(serde_json::from_value(params)?)),
675 "page" => Ok(Self::Page(serde_json::from_value(params)?)),
676 "pageError" => Ok(Self::PageError(serde_json::from_value(params)?)),
677 "route" => Ok(Self::Route(serde_json::from_value(params)?)),
678 "webSocketRoute" => Ok(Self::WebSocketRoute(serde_json::from_value(params)?)),
679 "serviceWorker" => Ok(Self::ServiceWorker(serde_json::from_value(params)?)),
680 "request" => Ok(Self::Request(serde_json::from_value(params)?)),
681 "requestFailed" => Ok(Self::RequestFailed(serde_json::from_value(params)?)),
682 "requestFinished" => Ok(Self::RequestFinished(serde_json::from_value(params)?)),
683 "response" => Ok(Self::Response(serde_json::from_value(params)?)),
684 "recorderEvent" => Ok(Self::RecorderEvent(serde_json::from_value(params)?)),
685 _ => Ok(Self::Unknown { method: method.to_string(), params }),
686 }
687 }
688}
689
690#[derive(Debug, Clone)]
692pub struct BrowserContext {
693 channel: Channel,
694}
695
696impl ChannelType for BrowserContext {
697 const INTERFACE: &'static str = "BrowserContext";
698 type Initializer = BrowserContextInitializer;
699 type Event = BrowserContextEvent;
700
701 fn accepts(interface: &str) -> bool {
702 matches!(interface, "BrowserContext")
703 }
704
705 fn from_channel(channel: Channel) -> Self {
706 Self { channel }
707 }
708
709 fn channel(&self) -> &Channel {
710 &self.channel
711 }
712}
713
714impl BrowserContext {
715 pub async fn add_cookies(&self, params: BrowserContextAddCookiesParams) -> Result<(), ProtocolError> {
717 self.channel.send_no_result("addCookies", ¶ms).await
718 }
719
720 pub async fn add_init_script(&self, params: BrowserContextAddInitScriptParams) -> Result<BrowserContextAddInitScriptResult, ProtocolError> {
722 self.channel.send("addInitScript", ¶ms).await
723 }
724
725 pub async fn clear_cookies(&self, params: BrowserContextClearCookiesParams) -> Result<(), ProtocolError> {
727 self.channel.send_no_result("clearCookies", ¶ms).await
728 }
729
730 pub async fn clear_permissions(&self) -> Result<(), ProtocolError> {
732 self.channel.send_no_result("clearPermissions", &serde_json::json!({})).await
733 }
734
735 pub async fn close(&self, params: BrowserContextCloseParams) -> Result<(), ProtocolError> {
737 self.channel.send_no_result("close", ¶ms).await
738 }
739
740 pub async fn cookies(&self, params: BrowserContextCookiesParams) -> Result<BrowserContextCookiesResult, ProtocolError> {
742 self.channel.send("cookies", ¶ms).await
743 }
744
745 pub async fn expose_binding(&self, params: BrowserContextExposeBindingParams) -> Result<BrowserContextExposeBindingResult, ProtocolError> {
747 self.channel.send("exposeBinding", ¶ms).await
748 }
749
750 pub async fn grant_permissions(&self, params: BrowserContextGrantPermissionsParams) -> Result<(), ProtocolError> {
752 self.channel.send_no_result("grantPermissions", ¶ms).await
753 }
754
755 pub async fn new_page(&self) -> Result<BrowserContextNewPageResult, ProtocolError> {
757 self.channel.send("newPage", &serde_json::json!({})).await
758 }
759
760 pub async fn register_selector_engine(&self, params: BrowserContextRegisterSelectorEngineParams) -> Result<(), ProtocolError> {
762 self.channel.send_no_result("registerSelectorEngine", ¶ms).await
763 }
764
765 pub async fn set_test_id_attribute_name(&self, params: BrowserContextSetTestIdAttributeNameParams) -> Result<(), ProtocolError> {
767 self.channel.send_no_result("setTestIdAttributeName", ¶ms).await
768 }
769
770 pub async fn set_extra_http_headers(&self, params: BrowserContextSetExtraHTTPHeadersParams) -> Result<(), ProtocolError> {
772 self.channel.send_no_result("setExtraHTTPHeaders", ¶ms).await
773 }
774
775 pub async fn set_geolocation(&self, params: BrowserContextSetGeolocationParams) -> Result<(), ProtocolError> {
777 self.channel.send_no_result("setGeolocation", ¶ms).await
778 }
779
780 pub async fn set_http_credentials(&self, params: BrowserContextSetHTTPCredentialsParams) -> Result<(), ProtocolError> {
782 self.channel.send_no_result("setHTTPCredentials", ¶ms).await
783 }
784
785 pub async fn set_network_interception_patterns(&self, params: BrowserContextSetNetworkInterceptionPatternsParams) -> Result<(), ProtocolError> {
787 self.channel.send_no_result("setNetworkInterceptionPatterns", ¶ms).await
788 }
789
790 pub async fn set_web_socket_interception_patterns(&self, params: BrowserContextSetWebSocketInterceptionPatternsParams) -> Result<(), ProtocolError> {
792 self.channel.send_no_result("setWebSocketInterceptionPatterns", ¶ms).await
793 }
794
795 pub async fn set_offline(&self, params: BrowserContextSetOfflineParams) -> Result<(), ProtocolError> {
797 self.channel.send_no_result("setOffline", ¶ms).await
798 }
799
800 pub async fn storage_state(&self, params: BrowserContextStorageStateParams) -> Result<BrowserContextStorageStateResult, ProtocolError> {
802 self.channel.send("storageState", ¶ms).await
803 }
804
805 pub async fn set_storage_state(&self, params: BrowserContextSetStorageStateParams) -> Result<(), ProtocolError> {
807 self.channel.send_no_result("setStorageState", ¶ms).await
808 }
809
810 pub async fn pause(&self) -> Result<(), ProtocolError> {
812 self.channel.send_no_result("pause", &serde_json::json!({})).await
813 }
814
815 pub async fn enable_recorder(&self, params: BrowserContextEnableRecorderParams) -> Result<(), ProtocolError> {
817 self.channel.send_no_result("enableRecorder", ¶ms).await
818 }
819
820 pub async fn disable_recorder(&self) -> Result<(), ProtocolError> {
822 self.channel.send_no_result("disableRecorder", &serde_json::json!({})).await
823 }
824
825 pub async fn expose_console_api(&self) -> Result<(), ProtocolError> {
827 self.channel.send_no_result("exposeConsoleApi", &serde_json::json!({})).await
828 }
829
830 pub async fn new_cdp_session(&self, params: BrowserContextNewCDPSessionParams) -> Result<BrowserContextNewCDPSessionResult, ProtocolError> {
832 self.channel.send("newCDPSession", ¶ms).await
833 }
834
835 pub async fn create_temp_files(&self, params: BrowserContextCreateTempFilesParams) -> Result<BrowserContextCreateTempFilesResult, ProtocolError> {
837 self.channel.send("createTempFiles", ¶ms).await
838 }
839
840 pub async fn update_subscription(&self, params: BrowserContextUpdateSubscriptionParams) -> Result<(), ProtocolError> {
842 self.channel.send_no_result("updateSubscription", ¶ms).await
843 }
844
845 pub async fn clock_fast_forward(&self, params: BrowserContextClockFastForwardParams) -> Result<(), ProtocolError> {
847 self.channel.send_no_result("clockFastForward", ¶ms).await
848 }
849
850 pub async fn clock_install(&self, params: BrowserContextClockInstallParams) -> Result<(), ProtocolError> {
852 self.channel.send_no_result("clockInstall", ¶ms).await
853 }
854
855 pub async fn clock_pause_at(&self, params: BrowserContextClockPauseAtParams) -> Result<(), ProtocolError> {
857 self.channel.send_no_result("clockPauseAt", ¶ms).await
858 }
859
860 pub async fn clock_resume(&self) -> Result<(), ProtocolError> {
862 self.channel.send_no_result("clockResume", &serde_json::json!({})).await
863 }
864
865 pub async fn clock_run_for(&self, params: BrowserContextClockRunForParams) -> Result<(), ProtocolError> {
867 self.channel.send_no_result("clockRunFor", ¶ms).await
868 }
869
870 pub async fn clock_set_fixed_time(&self, params: BrowserContextClockSetFixedTimeParams) -> Result<(), ProtocolError> {
872 self.channel.send_no_result("clockSetFixedTime", ¶ms).await
873 }
874
875 pub async fn clock_set_system_time(&self, params: BrowserContextClockSetSystemTimeParams) -> Result<(), ProtocolError> {
877 self.channel.send_no_result("clockSetSystemTime", ¶ms).await
878 }
879
880 pub async fn credentials_install(&self) -> Result<(), ProtocolError> {
882 self.channel.send_no_result("credentialsInstall", &serde_json::json!({})).await
883 }
884
885 pub async fn credentials_create(&self, params: BrowserContextCredentialsCreateParams) -> Result<BrowserContextCredentialsCreateResult, ProtocolError> {
887 self.channel.send("credentialsCreate", ¶ms).await
888 }
889
890 pub async fn credentials_get(&self, params: BrowserContextCredentialsGetParams) -> Result<BrowserContextCredentialsGetResult, ProtocolError> {
892 self.channel.send("credentialsGet", ¶ms).await
893 }
894
895 pub async fn credentials_delete(&self, params: BrowserContextCredentialsDeleteParams) -> Result<(), ProtocolError> {
897 self.channel.send_no_result("credentialsDelete", ¶ms).await
898 }
899}