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)]
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#[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#[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#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
218pub struct BrowserContextSetWebSocketInterceptionPatternsParams {
219 #[serde(rename = "patterns")]
220 pub patterns: Vec<BrowserContextSetWebSocketInterceptionPatternsParamsPatterns>,
221}
222
223#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
225pub struct BrowserContextSetOfflineParams {
226 #[serde(rename = "offline")]
227 pub offline: bool,
228}
229
230#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
453pub struct BrowserContextCredentialsCreateResult {
454 #[serde(rename = "credential")]
455 pub credential: VirtualCredential,
456}
457
458#[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#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
469pub struct BrowserContextCredentialsGetResult {
470 #[serde(rename = "credentials")]
471 pub credentials: Vec<VirtualCredential>,
472}
473
474#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
476pub struct BrowserContextCredentialsDeleteParams {
477 #[serde(rename = "id")]
478 pub id: String,
479}
480
481#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
483pub struct BrowserContextBindingCallEventParams {
484 #[serde(rename = "binding")]
485 pub binding: Ref<BindingCall>,
486}
487
488#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
490pub struct BrowserContextConsoleEventParams {
491 #[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#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
502pub struct BrowserContextDialogEventParams {
503 #[serde(rename = "dialog")]
504 pub dialog: Ref<Dialog>,
505}
506
507#[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#[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#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
537pub struct BrowserContextRouteEventParams {
538 #[serde(rename = "route")]
539 pub route: Ref<Route>,
540}
541
542#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
544pub struct BrowserContextWebSocketRouteEventParams {
545 #[serde(rename = "webSocketRoute")]
546 pub web_socket_route: Ref<WebSocketRoute>,
547}
548
549#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
551pub struct BrowserContextServiceWorkerEventParams {
552 #[serde(rename = "worker")]
553 pub worker: Ref<Worker>,
554}
555
556#[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#[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#[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#[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#[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#[derive(Debug, Clone, PartialEq)]
626pub enum BrowserContextEvent {
627 BindingCall(BrowserContextBindingCallEventParams),
629 Console(BrowserContextConsoleEventParams),
631 Close,
633 Dialog(BrowserContextDialogEventParams),
635 Page(BrowserContextPageEventParams),
637 PageError(BrowserContextPageErrorEventParams),
639 Route(BrowserContextRouteEventParams),
641 WebSocketRoute(BrowserContextWebSocketRouteEventParams),
643 ServiceWorker(BrowserContextServiceWorkerEventParams),
645 Request(BrowserContextRequestEventParams),
647 RequestFailed(BrowserContextRequestFailedEventParams),
649 RequestFinished(BrowserContextRequestFinishedEventParams),
651 Response(BrowserContextResponseEventParams),
653 RecorderEvent(BrowserContextRecorderEventEventParams),
655 Unknown {
657 method: String,
659 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#[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 pub async fn add_cookies(&self, params: BrowserContextAddCookiesParams) -> Result<(), ProtocolError> {
713 self.channel.send_no_result("addCookies", ¶ms).await
714 }
715
716 pub async fn add_init_script(&self, params: BrowserContextAddInitScriptParams) -> Result<BrowserContextAddInitScriptResult, ProtocolError> {
718 self.channel.send("addInitScript", ¶ms).await
719 }
720
721 pub async fn clear_cookies(&self, params: BrowserContextClearCookiesParams) -> Result<(), ProtocolError> {
723 self.channel.send_no_result("clearCookies", ¶ms).await
724 }
725
726 pub async fn clear_permissions(&self) -> Result<(), ProtocolError> {
728 self.channel.send_no_result("clearPermissions", &serde_json::json!({})).await
729 }
730
731 pub async fn close(&self, params: BrowserContextCloseParams) -> Result<(), ProtocolError> {
733 self.channel.send_no_result("close", ¶ms).await
734 }
735
736 pub async fn cookies(&self, params: BrowserContextCookiesParams) -> Result<BrowserContextCookiesResult, ProtocolError> {
738 self.channel.send("cookies", ¶ms).await
739 }
740
741 pub async fn expose_binding(&self, params: BrowserContextExposeBindingParams) -> Result<BrowserContextExposeBindingResult, ProtocolError> {
743 self.channel.send("exposeBinding", ¶ms).await
744 }
745
746 pub async fn grant_permissions(&self, params: BrowserContextGrantPermissionsParams) -> Result<(), ProtocolError> {
748 self.channel.send_no_result("grantPermissions", ¶ms).await
749 }
750
751 pub async fn new_page(&self) -> Result<BrowserContextNewPageResult, ProtocolError> {
753 self.channel.send("newPage", &serde_json::json!({})).await
754 }
755
756 pub async fn register_selector_engine(&self, params: BrowserContextRegisterSelectorEngineParams) -> Result<(), ProtocolError> {
758 self.channel.send_no_result("registerSelectorEngine", ¶ms).await
759 }
760
761 pub async fn set_test_id_attribute_name(&self, params: BrowserContextSetTestIdAttributeNameParams) -> Result<(), ProtocolError> {
763 self.channel.send_no_result("setTestIdAttributeName", ¶ms).await
764 }
765
766 pub async fn set_extra_http_headers(&self, params: BrowserContextSetExtraHTTPHeadersParams) -> Result<(), ProtocolError> {
768 self.channel.send_no_result("setExtraHTTPHeaders", ¶ms).await
769 }
770
771 pub async fn set_geolocation(&self, params: BrowserContextSetGeolocationParams) -> Result<(), ProtocolError> {
773 self.channel.send_no_result("setGeolocation", ¶ms).await
774 }
775
776 pub async fn set_http_credentials(&self, params: BrowserContextSetHTTPCredentialsParams) -> Result<(), ProtocolError> {
778 self.channel.send_no_result("setHTTPCredentials", ¶ms).await
779 }
780
781 pub async fn set_network_interception_patterns(&self, params: BrowserContextSetNetworkInterceptionPatternsParams) -> Result<(), ProtocolError> {
783 self.channel.send_no_result("setNetworkInterceptionPatterns", ¶ms).await
784 }
785
786 pub async fn set_web_socket_interception_patterns(&self, params: BrowserContextSetWebSocketInterceptionPatternsParams) -> Result<(), ProtocolError> {
788 self.channel.send_no_result("setWebSocketInterceptionPatterns", ¶ms).await
789 }
790
791 pub async fn set_offline(&self, params: BrowserContextSetOfflineParams) -> Result<(), ProtocolError> {
793 self.channel.send_no_result("setOffline", ¶ms).await
794 }
795
796 pub async fn storage_state(&self, params: BrowserContextStorageStateParams) -> Result<BrowserContextStorageStateResult, ProtocolError> {
798 self.channel.send("storageState", ¶ms).await
799 }
800
801 pub async fn set_storage_state(&self, params: BrowserContextSetStorageStateParams) -> Result<(), ProtocolError> {
803 self.channel.send_no_result("setStorageState", ¶ms).await
804 }
805
806 pub async fn pause(&self) -> Result<(), ProtocolError> {
808 self.channel.send_no_result("pause", &serde_json::json!({})).await
809 }
810
811 pub async fn enable_recorder(&self, params: BrowserContextEnableRecorderParams) -> Result<(), ProtocolError> {
813 self.channel.send_no_result("enableRecorder", ¶ms).await
814 }
815
816 pub async fn disable_recorder(&self) -> Result<(), ProtocolError> {
818 self.channel.send_no_result("disableRecorder", &serde_json::json!({})).await
819 }
820
821 pub async fn expose_console_api(&self) -> Result<(), ProtocolError> {
823 self.channel.send_no_result("exposeConsoleApi", &serde_json::json!({})).await
824 }
825
826 pub async fn new_cdp_session(&self, params: BrowserContextNewCDPSessionParams) -> Result<BrowserContextNewCDPSessionResult, ProtocolError> {
828 self.channel.send("newCDPSession", ¶ms).await
829 }
830
831 pub async fn create_temp_files(&self, params: BrowserContextCreateTempFilesParams) -> Result<BrowserContextCreateTempFilesResult, ProtocolError> {
833 self.channel.send("createTempFiles", ¶ms).await
834 }
835
836 pub async fn update_subscription(&self, params: BrowserContextUpdateSubscriptionParams) -> Result<(), ProtocolError> {
838 self.channel.send_no_result("updateSubscription", ¶ms).await
839 }
840
841 pub async fn clock_fast_forward(&self, params: BrowserContextClockFastForwardParams) -> Result<(), ProtocolError> {
843 self.channel.send_no_result("clockFastForward", ¶ms).await
844 }
845
846 pub async fn clock_install(&self, params: BrowserContextClockInstallParams) -> Result<(), ProtocolError> {
848 self.channel.send_no_result("clockInstall", ¶ms).await
849 }
850
851 pub async fn clock_pause_at(&self, params: BrowserContextClockPauseAtParams) -> Result<(), ProtocolError> {
853 self.channel.send_no_result("clockPauseAt", ¶ms).await
854 }
855
856 pub async fn clock_resume(&self) -> Result<(), ProtocolError> {
858 self.channel.send_no_result("clockResume", &serde_json::json!({})).await
859 }
860
861 pub async fn clock_run_for(&self, params: BrowserContextClockRunForParams) -> Result<(), ProtocolError> {
863 self.channel.send_no_result("clockRunFor", ¶ms).await
864 }
865
866 pub async fn clock_set_fixed_time(&self, params: BrowserContextClockSetFixedTimeParams) -> Result<(), ProtocolError> {
868 self.channel.send_no_result("clockSetFixedTime", ¶ms).await
869 }
870
871 pub async fn clock_set_system_time(&self, params: BrowserContextClockSetSystemTimeParams) -> Result<(), ProtocolError> {
873 self.channel.send_no_result("clockSetSystemTime", ¶ms).await
874 }
875
876 pub async fn credentials_install(&self) -> Result<(), ProtocolError> {
878 self.channel.send_no_result("credentialsInstall", &serde_json::json!({})).await
879 }
880
881 pub async fn credentials_create(&self, params: BrowserContextCredentialsCreateParams) -> Result<BrowserContextCredentialsCreateResult, ProtocolError> {
883 self.channel.send("credentialsCreate", ¶ms).await
884 }
885
886 pub async fn credentials_get(&self, params: BrowserContextCredentialsGetParams) -> Result<BrowserContextCredentialsGetResult, ProtocolError> {
888 self.channel.send("credentialsGet", ¶ms).await
889 }
890
891 pub async fn credentials_delete(&self, params: BrowserContextCredentialsDeleteParams) -> Result<(), ProtocolError> {
893 self.channel.send_no_result("credentialsDelete", ¶ms).await
894 }
895}