rustenium_bidi_definitions/network/
commands.rs

1use serde::{Deserialize, Serialize};
2#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3pub struct AddDataCollectorParams {
4    #[serde(rename = "dataTypes")]
5    #[serde(skip_serializing_if = "Vec::is_empty")]
6    pub data_types: Vec<super::types::DataType>,
7    #[serde(rename = "maxEncodedDataSize")]
8    pub max_encoded_data_size: u64,
9    #[serde(rename = "collectorType")]
10    #[serde(skip_serializing_if = "Option::is_none")]
11    #[serde(default)]
12    pub collector_type: Option<super::types::CollectorType>,
13    #[serde(rename = "contexts")]
14    #[serde(skip_serializing_if = "Option::is_none")]
15    #[serde(default)]
16    pub contexts: Option<Vec<crate::browsing_context::types::BrowsingContext>>,
17    #[serde(rename = "userContexts")]
18    #[serde(skip_serializing_if = "Option::is_none")]
19    #[serde(default)]
20    pub user_contexts: Option<Vec<crate::browser::types::UserContext>>,
21}
22impl AddDataCollectorParams {
23    pub fn new(
24        data_types: Vec<super::types::DataType>,
25        max_encoded_data_size: impl Into<u64>,
26    ) -> Self {
27        Self {
28            data_types,
29            max_encoded_data_size: max_encoded_data_size.into(),
30            collector_type: None,
31            contexts: None,
32            user_contexts: None,
33        }
34    }
35}
36#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
37pub enum AddDataCollectorMethod {
38    #[serde(rename = "network.addDataCollector")]
39    AddDataCollector,
40}
41#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
42pub struct AddDataCollector {
43    pub method: AddDataCollectorMethod,
44    pub params: AddDataCollectorParams,
45}
46impl AddDataCollector {
47    pub const IDENTIFIER: &'static str = "network.addDataCollector";
48    pub const DOMAIN_DIRECTION: &'static str = "remote";
49    pub fn identifier(&self) -> &'static str {
50        Self::IDENTIFIER
51    }
52}
53impl crate::CommandResult for AddDataCollector {
54    type Result = super::results::AddDataCollectorResult;
55}
56#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
57pub struct AddInterceptParams {
58    #[serde(rename = "phases")]
59    #[serde(skip_serializing_if = "Vec::is_empty")]
60    pub phases: Vec<super::types::InterceptPhase>,
61    #[serde(rename = "contexts")]
62    #[serde(skip_serializing_if = "Option::is_none")]
63    #[serde(default)]
64    pub contexts: Option<Vec<crate::browsing_context::types::BrowsingContext>>,
65    #[serde(rename = "urlPatterns")]
66    #[serde(skip_serializing_if = "Option::is_none")]
67    #[serde(default)]
68    pub url_patterns: Option<Vec<super::types::UrlPattern>>,
69}
70impl AddInterceptParams {
71    pub fn new(phases: Vec<super::types::InterceptPhase>) -> Self {
72        Self {
73            phases,
74            contexts: None,
75            url_patterns: None,
76        }
77    }
78}
79#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
80pub enum AddInterceptMethod {
81    #[serde(rename = "network.addIntercept")]
82    AddIntercept,
83}
84#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
85pub struct AddIntercept {
86    pub method: AddInterceptMethod,
87    pub params: AddInterceptParams,
88}
89impl AddIntercept {
90    pub const IDENTIFIER: &'static str = "network.addIntercept";
91    pub const DOMAIN_DIRECTION: &'static str = "remote";
92    pub fn identifier(&self) -> &'static str {
93        Self::IDENTIFIER
94    }
95}
96impl crate::CommandResult for AddIntercept {
97    type Result = super::results::AddInterceptResult;
98}
99#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
100pub struct ContinueRequestParams {
101    #[serde(rename = "request")]
102    pub request: super::types::Request,
103    #[serde(rename = "body")]
104    #[serde(skip_serializing_if = "Option::is_none")]
105    #[serde(default)]
106    pub body: Option<super::types::BytesValue>,
107    #[serde(rename = "cookies")]
108    #[serde(skip_serializing_if = "Option::is_none")]
109    #[serde(default)]
110    pub cookies: Option<Vec<super::types::CookieHeader>>,
111    #[serde(rename = "headers")]
112    #[serde(skip_serializing_if = "Option::is_none")]
113    #[serde(default)]
114    pub headers: Option<Vec<super::types::Header>>,
115    #[serde(rename = "method")]
116    #[serde(skip_serializing_if = "Option::is_none")]
117    #[serde(default)]
118    pub method: Option<String>,
119    #[serde(rename = "url")]
120    #[serde(skip_serializing_if = "Option::is_none")]
121    #[serde(default)]
122    pub url: Option<String>,
123}
124impl ContinueRequestParams {
125    pub fn new(request: impl Into<super::types::Request>) -> Self {
126        Self {
127            request: request.into(),
128            body: None,
129            cookies: None,
130            headers: None,
131            method: None,
132            url: None,
133        }
134    }
135}
136#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
137pub enum ContinueRequestMethod {
138    #[serde(rename = "network.continueRequest")]
139    ContinueRequest,
140}
141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
142pub struct ContinueRequest {
143    pub method: ContinueRequestMethod,
144    pub params: ContinueRequestParams,
145}
146impl ContinueRequest {
147    pub const IDENTIFIER: &'static str = "network.continueRequest";
148    pub const DOMAIN_DIRECTION: &'static str = "remote";
149    pub fn identifier(&self) -> &'static str {
150        Self::IDENTIFIER
151    }
152}
153impl crate::CommandResult for ContinueRequest {
154    type Result = super::results::ContinueRequestResult;
155}
156#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
157pub struct ContinueResponseParams {
158    #[serde(rename = "request")]
159    pub request: super::types::Request,
160    #[serde(rename = "cookies")]
161    #[serde(skip_serializing_if = "Option::is_none")]
162    #[serde(default)]
163    pub cookies: Option<Vec<super::types::SetCookieHeader>>,
164    #[serde(rename = "credentials")]
165    #[serde(skip_serializing_if = "Option::is_none")]
166    #[serde(default)]
167    pub credentials: Option<super::types::AuthCredentials>,
168    #[serde(rename = "headers")]
169    #[serde(skip_serializing_if = "Option::is_none")]
170    #[serde(default)]
171    pub headers: Option<Vec<super::types::Header>>,
172    #[serde(rename = "reasonPhrase")]
173    #[serde(skip_serializing_if = "Option::is_none")]
174    #[serde(default)]
175    pub reason_phrase: Option<String>,
176    #[serde(rename = "statusCode")]
177    #[serde(skip_serializing_if = "Option::is_none")]
178    #[serde(default)]
179    pub status_code: Option<u64>,
180}
181impl ContinueResponseParams {
182    pub fn new(request: impl Into<super::types::Request>) -> Self {
183        Self {
184            request: request.into(),
185            cookies: None,
186            credentials: None,
187            headers: None,
188            reason_phrase: None,
189            status_code: None,
190        }
191    }
192}
193#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
194pub enum ContinueResponseMethod {
195    #[serde(rename = "network.continueResponse")]
196    ContinueResponse,
197}
198#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
199pub struct ContinueResponse {
200    pub method: ContinueResponseMethod,
201    pub params: ContinueResponseParams,
202}
203impl ContinueResponse {
204    pub const IDENTIFIER: &'static str = "network.continueResponse";
205    pub const DOMAIN_DIRECTION: &'static str = "remote";
206    pub fn identifier(&self) -> &'static str {
207        Self::IDENTIFIER
208    }
209}
210impl crate::CommandResult for ContinueResponse {
211    type Result = super::results::ContinueResponseResult;
212}
213#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
214pub struct ContinueWithAuthParams {
215    #[serde(rename = "request")]
216    pub request: super::types::Request,
217    #[serde(flatten)]
218    #[serde(default)]
219    pub continue_with_auth_credentials_continue_with_auth_no_credentials_union:
220        super::types::ContinueWithAuthCredentialsContinueWithAuthNoCredentialsUnion,
221}
222impl ContinueWithAuthParams {
223    pub fn new(
224        request: impl Into<super::types::Request>,
225        continue_with_auth_credentials_continue_with_auth_no_credentials_union: impl Into<
226            super::types::ContinueWithAuthCredentialsContinueWithAuthNoCredentialsUnion,
227        >,
228    ) -> Self {
229        Self {
230            request: request.into(),
231            continue_with_auth_credentials_continue_with_auth_no_credentials_union:
232                continue_with_auth_credentials_continue_with_auth_no_credentials_union.into(),
233        }
234    }
235}
236#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
237pub enum ContinueWithAuthMethod {
238    #[serde(rename = "network.continueWithAuth")]
239    ContinueWithAuth,
240}
241#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
242pub struct ContinueWithAuth {
243    pub method: ContinueWithAuthMethod,
244    pub params: ContinueWithAuthParams,
245}
246impl ContinueWithAuth {
247    pub const IDENTIFIER: &'static str = "network.continueWithAuth";
248    pub const DOMAIN_DIRECTION: &'static str = "remote";
249    pub fn identifier(&self) -> &'static str {
250        Self::IDENTIFIER
251    }
252}
253impl crate::CommandResult for ContinueWithAuth {
254    type Result = super::results::ContinueWithAuthResult;
255}
256#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
257pub struct DisownDataParams {
258    #[serde(rename = "dataType")]
259    pub data_type: super::types::DataType,
260    #[serde(rename = "collector")]
261    pub collector: super::types::Collector,
262    #[serde(rename = "request")]
263    pub request: super::types::Request,
264}
265impl DisownDataParams {
266    pub fn new(
267        data_type: impl Into<super::types::DataType>,
268        collector: impl Into<super::types::Collector>,
269        request: impl Into<super::types::Request>,
270    ) -> Self {
271        Self {
272            data_type: data_type.into(),
273            collector: collector.into(),
274            request: request.into(),
275        }
276    }
277}
278#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
279pub enum DisownDataMethod {
280    #[serde(rename = "network.disownData")]
281    DisownData,
282}
283#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
284pub struct DisownData {
285    pub method: DisownDataMethod,
286    pub params: DisownDataParams,
287}
288impl DisownData {
289    pub const IDENTIFIER: &'static str = "network.disownData";
290    pub const DOMAIN_DIRECTION: &'static str = "remote";
291    pub fn identifier(&self) -> &'static str {
292        Self::IDENTIFIER
293    }
294}
295impl crate::CommandResult for DisownData {
296    type Result = super::results::DisownDataResult;
297}
298#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
299pub struct FailRequestParams {
300    #[serde(rename = "request")]
301    pub request: super::types::Request,
302}
303impl FailRequestParams {
304    pub fn new(request: impl Into<super::types::Request>) -> Self {
305        Self {
306            request: request.into(),
307        }
308    }
309}
310#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
311pub enum FailRequestMethod {
312    #[serde(rename = "network.failRequest")]
313    FailRequest,
314}
315#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
316pub struct FailRequest {
317    pub method: FailRequestMethod,
318    pub params: FailRequestParams,
319}
320impl FailRequest {
321    pub const IDENTIFIER: &'static str = "network.failRequest";
322    pub const DOMAIN_DIRECTION: &'static str = "remote";
323    pub fn identifier(&self) -> &'static str {
324        Self::IDENTIFIER
325    }
326}
327impl crate::CommandResult for FailRequest {
328    type Result = super::results::FailRequestResult;
329}
330#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
331pub struct GetDataParams {
332    #[serde(rename = "dataType")]
333    pub data_type: super::types::DataType,
334    #[serde(rename = "collector")]
335    #[serde(skip_serializing_if = "Option::is_none")]
336    #[serde(default)]
337    pub collector: Option<super::types::Collector>,
338    #[serde(rename = "disown")]
339    #[serde(skip_serializing_if = "Option::is_none")]
340    #[serde(default = "default_get_data_params_disown")]
341    pub disown: Option<bool>,
342    #[serde(rename = "request")]
343    pub request: super::types::Request,
344}
345fn default_get_data_params_disown() -> Option<bool> {
346    Some(false)
347}
348impl GetDataParams {
349    pub fn new(
350        data_type: impl Into<super::types::DataType>,
351        request: impl Into<super::types::Request>,
352    ) -> Self {
353        Self {
354            data_type: data_type.into(),
355            request: request.into(),
356            collector: None,
357            disown: None,
358        }
359    }
360}
361#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
362pub enum GetDataMethod {
363    #[serde(rename = "network.getData")]
364    GetData,
365}
366#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
367pub struct GetData {
368    pub method: GetDataMethod,
369    pub params: GetDataParams,
370}
371impl GetData {
372    pub const IDENTIFIER: &'static str = "network.getData";
373    pub const DOMAIN_DIRECTION: &'static str = "remote";
374    pub fn identifier(&self) -> &'static str {
375        Self::IDENTIFIER
376    }
377}
378impl crate::CommandResult for GetData {
379    type Result = super::results::GetDataResult;
380}
381#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
382pub struct ProvideResponseParams {
383    #[serde(rename = "request")]
384    pub request: super::types::Request,
385    #[serde(rename = "body")]
386    #[serde(skip_serializing_if = "Option::is_none")]
387    #[serde(default)]
388    pub body: Option<super::types::BytesValue>,
389    #[serde(rename = "cookies")]
390    #[serde(skip_serializing_if = "Option::is_none")]
391    #[serde(default)]
392    pub cookies: Option<Vec<super::types::SetCookieHeader>>,
393    #[serde(rename = "headers")]
394    #[serde(skip_serializing_if = "Option::is_none")]
395    #[serde(default)]
396    pub headers: Option<Vec<super::types::Header>>,
397    #[serde(rename = "reasonPhrase")]
398    #[serde(skip_serializing_if = "Option::is_none")]
399    #[serde(default)]
400    pub reason_phrase: Option<String>,
401    #[serde(rename = "statusCode")]
402    #[serde(skip_serializing_if = "Option::is_none")]
403    #[serde(default)]
404    pub status_code: Option<u64>,
405}
406impl ProvideResponseParams {
407    pub fn new(request: impl Into<super::types::Request>) -> Self {
408        Self {
409            request: request.into(),
410            body: None,
411            cookies: None,
412            headers: None,
413            reason_phrase: None,
414            status_code: None,
415        }
416    }
417}
418#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
419pub enum ProvideResponseMethod {
420    #[serde(rename = "network.provideResponse")]
421    ProvideResponse,
422}
423#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
424pub struct ProvideResponse {
425    pub method: ProvideResponseMethod,
426    pub params: ProvideResponseParams,
427}
428impl ProvideResponse {
429    pub const IDENTIFIER: &'static str = "network.provideResponse";
430    pub const DOMAIN_DIRECTION: &'static str = "remote";
431    pub fn identifier(&self) -> &'static str {
432        Self::IDENTIFIER
433    }
434}
435impl crate::CommandResult for ProvideResponse {
436    type Result = super::results::ProvideResponseResult;
437}
438#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
439pub struct RemoveDataCollectorParams {
440    #[serde(rename = "collector")]
441    pub collector: super::types::Collector,
442}
443impl RemoveDataCollectorParams {
444    pub fn new(collector: impl Into<super::types::Collector>) -> Self {
445        Self {
446            collector: collector.into(),
447        }
448    }
449}
450#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
451pub enum RemoveDataCollectorMethod {
452    #[serde(rename = "network.removeDataCollector")]
453    RemoveDataCollector,
454}
455#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
456pub struct RemoveDataCollector {
457    pub method: RemoveDataCollectorMethod,
458    pub params: RemoveDataCollectorParams,
459}
460impl RemoveDataCollector {
461    pub const IDENTIFIER: &'static str = "network.removeDataCollector";
462    pub const DOMAIN_DIRECTION: &'static str = "remote";
463    pub fn identifier(&self) -> &'static str {
464        Self::IDENTIFIER
465    }
466}
467impl crate::CommandResult for RemoveDataCollector {
468    type Result = super::results::RemoveDataCollectorResult;
469}
470#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
471pub struct RemoveInterceptParams {
472    #[serde(rename = "intercept")]
473    pub intercept: super::types::Intercept,
474}
475impl RemoveInterceptParams {
476    pub fn new(intercept: impl Into<super::types::Intercept>) -> Self {
477        Self {
478            intercept: intercept.into(),
479        }
480    }
481}
482#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
483pub enum RemoveInterceptMethod {
484    #[serde(rename = "network.removeIntercept")]
485    RemoveIntercept,
486}
487#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
488pub struct RemoveIntercept {
489    pub method: RemoveInterceptMethod,
490    pub params: RemoveInterceptParams,
491}
492impl RemoveIntercept {
493    pub const IDENTIFIER: &'static str = "network.removeIntercept";
494    pub const DOMAIN_DIRECTION: &'static str = "remote";
495    pub fn identifier(&self) -> &'static str {
496        Self::IDENTIFIER
497    }
498}
499impl crate::CommandResult for RemoveIntercept {
500    type Result = super::results::RemoveInterceptResult;
501}
502#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
503pub struct SetCacheBehaviorParams {
504    #[serde(rename = "cacheBehavior")]
505    pub cache_behavior: SetCacheBehaviorCacheBehavior,
506    #[serde(rename = "contexts")]
507    #[serde(skip_serializing_if = "Option::is_none")]
508    #[serde(default)]
509    pub contexts: Option<Vec<crate::browsing_context::types::BrowsingContext>>,
510}
511#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
512pub enum SetCacheBehaviorCacheBehavior {
513    #[serde(rename = "default")]
514    Default,
515    #[serde(rename = "bypass")]
516    Bypass,
517}
518impl SetCacheBehaviorParams {
519    pub fn new(cache_behavior: impl Into<SetCacheBehaviorCacheBehavior>) -> Self {
520        Self {
521            cache_behavior: cache_behavior.into(),
522            contexts: None,
523        }
524    }
525}
526#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
527pub enum SetCacheBehaviorMethod {
528    #[serde(rename = "network.setCacheBehavior")]
529    SetCacheBehavior,
530}
531#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
532pub struct SetCacheBehavior {
533    pub method: SetCacheBehaviorMethod,
534    pub params: SetCacheBehaviorParams,
535}
536impl SetCacheBehavior {
537    pub const IDENTIFIER: &'static str = "network.setCacheBehavior";
538    pub const DOMAIN_DIRECTION: &'static str = "remote";
539    pub fn identifier(&self) -> &'static str {
540        Self::IDENTIFIER
541    }
542}
543impl crate::CommandResult for SetCacheBehavior {
544    type Result = super::results::SetCacheBehaviorResult;
545}
546#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
547pub struct SetExtraHeadersParams {
548    #[serde(rename = "headers")]
549    #[serde(skip_serializing_if = "Vec::is_empty")]
550    pub headers: Vec<super::types::Header>,
551    #[serde(rename = "contexts")]
552    #[serde(skip_serializing_if = "Option::is_none")]
553    #[serde(default)]
554    pub contexts: Option<Vec<crate::browsing_context::types::BrowsingContext>>,
555    #[serde(rename = "userContexts")]
556    #[serde(skip_serializing_if = "Option::is_none")]
557    #[serde(default)]
558    pub user_contexts: Option<Vec<crate::browser::types::UserContext>>,
559}
560impl SetExtraHeadersParams {
561    pub fn new(headers: Vec<super::types::Header>) -> Self {
562        Self {
563            headers,
564            contexts: None,
565            user_contexts: None,
566        }
567    }
568}
569#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
570pub enum SetExtraHeadersMethod {
571    #[serde(rename = "network.setExtraHeaders")]
572    SetExtraHeaders,
573}
574#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
575pub struct SetExtraHeaders {
576    pub method: SetExtraHeadersMethod,
577    pub params: SetExtraHeadersParams,
578}
579impl SetExtraHeaders {
580    pub const IDENTIFIER: &'static str = "network.setExtraHeaders";
581    pub const DOMAIN_DIRECTION: &'static str = "remote";
582    pub fn identifier(&self) -> &'static str {
583        Self::IDENTIFIER
584    }
585}
586impl crate::CommandResult for SetExtraHeaders {
587    type Result = super::results::SetExtraHeadersResult;
588}
589group_enum ! (NetworkCommand { AddDataCollector (AddDataCollector) , AddIntercept (AddIntercept) , ContinueRequest (ContinueRequest) , ContinueResponse (ContinueResponse) , ContinueWithAuth (ContinueWithAuth) , DisownData (DisownData) , FailRequest (FailRequest) , GetData (GetData) , ProvideResponse (ProvideResponse) , RemoveDataCollector (RemoveDataCollector) , RemoveIntercept (RemoveIntercept) , SetCacheBehavior (SetCacheBehavior) , SetExtraHeaders (SetExtraHeaders) } + identifiable);
rustenium_bidi_definitions/network/commands.rs

rustenium_bidi_definitions/network/
commands.rs
