Skip to main content

rustenium_cdp_definitions/browser_protocol/target/
results.rs

1use serde::{Deserialize, Serialize};
2#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3pub struct ActivateTargetResult {}
4impl TryFrom<serde_json::Value> for ActivateTargetResult {
5    type Error = serde_json::Error;
6    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
7        serde_json::from_value(value)
8    }
9}
10#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11pub struct AttachToTargetResult {
12    #[doc = "Id assigned to the session."]
13    #[serde(rename = "sessionId")]
14    pub session_id: super::types::SessionId,
15}
16impl TryFrom<serde_json::Value> for AttachToTargetResult {
17    type Error = serde_json::Error;
18    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
19        serde_json::from_value(value)
20    }
21}
22#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
23pub struct AttachToBrowserTargetResult {
24    #[doc = "Id assigned to the session."]
25    #[serde(rename = "sessionId")]
26    pub session_id: super::types::SessionId,
27}
28impl TryFrom<serde_json::Value> for AttachToBrowserTargetResult {
29    type Error = serde_json::Error;
30    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
31        serde_json::from_value(value)
32    }
33}
34#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
35pub struct CloseTargetResult {}
36impl TryFrom<serde_json::Value> for CloseTargetResult {
37    type Error = serde_json::Error;
38    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
39        serde_json::from_value(value)
40    }
41}
42#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
43pub struct ExposeDevToolsProtocolResult {}
44impl TryFrom<serde_json::Value> for ExposeDevToolsProtocolResult {
45    type Error = serde_json::Error;
46    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
47        serde_json::from_value(value)
48    }
49}
50#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
51pub struct CreateBrowserContextResult {
52    #[doc = "The id of the context created."]
53    #[serde(rename = "browserContextId")]
54    pub browser_context_id: crate::browser_protocol::browser::types::BrowserContextId,
55}
56impl TryFrom<serde_json::Value> for CreateBrowserContextResult {
57    type Error = serde_json::Error;
58    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
59        serde_json::from_value(value)
60    }
61}
62#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
63pub struct GetBrowserContextsResult {
64    #[doc = "An array of browser context ids."]
65    #[serde(rename = "browserContextIds")]
66    #[serde(skip_serializing_if = "Vec::is_empty")]
67    pub browser_context_ids: Vec<crate::browser_protocol::browser::types::BrowserContextId>,
68    #[doc = "The id of the default browser context if available."]
69    #[serde(rename = "defaultBrowserContextId")]
70    #[serde(skip_serializing_if = "Option::is_none")]
71    #[serde(default)]
72    pub default_browser_context_id:
73        Option<crate::browser_protocol::browser::types::BrowserContextId>,
74}
75impl TryFrom<serde_json::Value> for GetBrowserContextsResult {
76    type Error = serde_json::Error;
77    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
78        serde_json::from_value(value)
79    }
80}
81#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
82pub struct CreateTargetResult {
83    #[doc = "The id of the page opened."]
84    #[serde(rename = "targetId")]
85    pub target_id: super::types::TargetId,
86}
87impl TryFrom<serde_json::Value> for CreateTargetResult {
88    type Error = serde_json::Error;
89    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
90        serde_json::from_value(value)
91    }
92}
93#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
94pub struct DetachFromTargetResult {}
95impl TryFrom<serde_json::Value> for DetachFromTargetResult {
96    type Error = serde_json::Error;
97    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
98        serde_json::from_value(value)
99    }
100}
101#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
102pub struct DisposeBrowserContextResult {}
103impl TryFrom<serde_json::Value> for DisposeBrowserContextResult {
104    type Error = serde_json::Error;
105    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
106        serde_json::from_value(value)
107    }
108}
109#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
110pub struct GetTargetInfoResult {
111    #[serde(rename = "targetInfo")]
112    pub target_info: super::types::TargetInfo,
113}
114impl TryFrom<serde_json::Value> for GetTargetInfoResult {
115    type Error = serde_json::Error;
116    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
117        serde_json::from_value(value)
118    }
119}
120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
121pub struct GetTargetsResult {
122    #[doc = "The list of targets."]
123    #[serde(rename = "targetInfos")]
124    #[serde(skip_serializing_if = "Vec::is_empty")]
125    pub target_infos: Vec<super::types::TargetInfo>,
126}
127impl TryFrom<serde_json::Value> for GetTargetsResult {
128    type Error = serde_json::Error;
129    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
130        serde_json::from_value(value)
131    }
132}
133#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
134pub struct SendMessageToTargetResult {}
135impl TryFrom<serde_json::Value> for SendMessageToTargetResult {
136    type Error = serde_json::Error;
137    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
138        serde_json::from_value(value)
139    }
140}
141#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
142pub struct SetAutoAttachResult {}
143impl TryFrom<serde_json::Value> for SetAutoAttachResult {
144    type Error = serde_json::Error;
145    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
146        serde_json::from_value(value)
147    }
148}
149#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
150pub struct AutoAttachRelatedResult {}
151impl TryFrom<serde_json::Value> for AutoAttachRelatedResult {
152    type Error = serde_json::Error;
153    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
154        serde_json::from_value(value)
155    }
156}
157#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
158pub struct SetDiscoverTargetsResult {}
159impl TryFrom<serde_json::Value> for SetDiscoverTargetsResult {
160    type Error = serde_json::Error;
161    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
162        serde_json::from_value(value)
163    }
164}
165#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
166pub struct SetRemoteLocationsResult {}
167impl TryFrom<serde_json::Value> for SetRemoteLocationsResult {
168    type Error = serde_json::Error;
169    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
170        serde_json::from_value(value)
171    }
172}
173#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
174pub struct GetDevToolsTargetResult {
175    #[doc = "The targetId of DevTools page target if exists."]
176    #[serde(rename = "targetId")]
177    #[serde(skip_serializing_if = "Option::is_none")]
178    #[serde(default)]
179    pub target_id: Option<super::types::TargetId>,
180}
181impl TryFrom<serde_json::Value> for GetDevToolsTargetResult {
182    type Error = serde_json::Error;
183    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
184        serde_json::from_value(value)
185    }
186}
187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
188pub struct OpenDevToolsResult {
189    #[doc = "The targetId of DevTools page target."]
190    #[serde(rename = "targetId")]
191    pub target_id: super::types::TargetId,
192}
193impl TryFrom<serde_json::Value> for OpenDevToolsResult {
194    type Error = serde_json::Error;
195    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
196        serde_json::from_value(value)
197    }
198}