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)]
15pub struct TracingInitializer {}
16
17#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
19pub struct TracingTracingStartParams {
20 #[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
21 pub name: Option<String>,
22 #[serde(rename = "snapshotDom", default, skip_serializing_if = "Option::is_none")]
23 pub snapshot_dom: Option<bool>,
24 #[serde(rename = "snapshotAria", default, skip_serializing_if = "Option::is_none")]
25 pub snapshot_aria: Option<bool>,
26 #[serde(rename = "snapshotScreen", default, skip_serializing_if = "Option::is_none")]
27 pub snapshot_screen: Option<bool>,
28 #[serde(rename = "screencast", default, skip_serializing_if = "Option::is_none")]
29 pub screencast: Option<bool>,
30 #[serde(rename = "live", default, skip_serializing_if = "Option::is_none")]
31 pub live: Option<bool>,
32}
33
34#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
36pub struct TracingTracingStartChunkParams {
37 #[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
38 pub name: Option<String>,
39 #[serde(rename = "title", default, skip_serializing_if = "Option::is_none")]
40 pub title: Option<String>,
41}
42
43#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
45pub struct TracingTracingStartChunkResult {
46 #[serde(rename = "traceName")]
47 pub trace_name: String,
48}
49
50#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
51pub struct TracingTracingGroupParamsLocation {
52 #[serde(rename = "file")]
53 pub file: String,
54 #[serde(rename = "line", default, skip_serializing_if = "Option::is_none")]
55 pub line: Option<i64>,
56 #[serde(rename = "column", default, skip_serializing_if = "Option::is_none")]
57 pub column: Option<i64>,
58}
59
60#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
62pub struct TracingTracingGroupParams {
63 #[serde(rename = "name")]
64 pub name: String,
65 #[serde(rename = "location", default, skip_serializing_if = "Option::is_none")]
66 pub location: Option<TracingTracingGroupParamsLocation>,
67}
68
69#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
70pub enum TracingTracingStopChunkParamsMode {
71 #[default]
72 #[serde(rename = "archive")]
73 Archive,
74 #[serde(rename = "discard")]
75 Discard,
76 #[serde(rename = "entries")]
77 Entries,
78}
79
80#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
82pub struct TracingTracingStopChunkParams {
83 #[serde(rename = "mode")]
84 pub mode: TracingTracingStopChunkParamsMode,
85}
86
87#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
89pub struct TracingTracingStopChunkResult {
90 #[serde(rename = "artifact", default, skip_serializing_if = "Option::is_none")]
91 pub artifact: Option<Ref<Artifact>>,
92 #[serde(rename = "entries", default, skip_serializing_if = "Option::is_none")]
93 pub entries: Option<Vec<NameValue>>,
94}
95
96#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
98pub struct TracingHarStartParams {
99 #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
100 pub page: Option<Ref<Page>>,
101 #[serde(rename = "options")]
102 pub options: RecordHarOptions,
103}
104
105#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
107pub struct TracingHarStartResult {
108 #[serde(rename = "harId")]
109 pub har_id: String,
110}
111
112#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
113pub enum TracingHarExportParamsMode {
114 #[default]
115 #[serde(rename = "archive")]
116 Archive,
117 #[serde(rename = "entries")]
118 Entries,
119}
120
121#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
123pub struct TracingHarExportParams {
124 #[serde(rename = "harId", default, skip_serializing_if = "Option::is_none")]
125 pub har_id: Option<String>,
126 #[serde(rename = "mode")]
127 pub mode: TracingHarExportParamsMode,
128}
129
130#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
132pub struct TracingHarExportResult {
133 #[serde(rename = "artifact", default, skip_serializing_if = "Option::is_none")]
134 pub artifact: Option<Ref<Artifact>>,
135 #[serde(rename = "entries", default, skip_serializing_if = "Option::is_none")]
136 pub entries: Option<Vec<NameValue>>,
137}
138
139#[derive(Debug, Clone, PartialEq)]
141pub enum TracingEvent {
142 Unknown {
144 method: String,
146 params: serde_json::Value,
148 },
149}
150
151impl ProtocolEvent for TracingEvent {
152 fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
153 match method {
154 _ => Ok(Self::Unknown { method: method.to_string(), params }),
155 }
156 }
157}
158
159#[derive(Debug, Clone)]
161pub struct Tracing {
162 channel: Channel,
163}
164
165impl ChannelType for Tracing {
166 const INTERFACE: &'static str = "Tracing";
167 type Initializer = TracingInitializer;
168 type Event = TracingEvent;
169
170 fn accepts(interface: &str) -> bool {
171 matches!(interface, "Tracing")
172 }
173
174 fn from_channel(channel: Channel) -> Self {
175 Self { channel }
176 }
177
178 fn channel(&self) -> &Channel {
179 &self.channel
180 }
181}
182
183impl Tracing {
184 pub async fn tracing_start(&self, params: TracingTracingStartParams) -> Result<(), ProtocolError> {
186 self.channel.send_no_result("tracingStart", ¶ms).await
187 }
188
189 pub async fn tracing_start_chunk(&self, params: TracingTracingStartChunkParams) -> Result<TracingTracingStartChunkResult, ProtocolError> {
191 self.channel.send("tracingStartChunk", ¶ms).await
192 }
193
194 pub async fn tracing_group(&self, params: TracingTracingGroupParams) -> Result<(), ProtocolError> {
196 self.channel.send_no_result("tracingGroup", ¶ms).await
197 }
198
199 pub async fn tracing_group_end(&self) -> Result<(), ProtocolError> {
201 self.channel.send_no_result("tracingGroupEnd", &serde_json::json!({})).await
202 }
203
204 pub async fn tracing_stop_chunk(&self, params: TracingTracingStopChunkParams) -> Result<TracingTracingStopChunkResult, ProtocolError> {
206 self.channel.send("tracingStopChunk", ¶ms).await
207 }
208
209 pub async fn tracing_stop(&self) -> Result<(), ProtocolError> {
211 self.channel.send_no_result("tracingStop", &serde_json::json!({})).await
212 }
213
214 pub async fn har_start(&self, params: TracingHarStartParams) -> Result<TracingHarStartResult, ProtocolError> {
216 self.channel.send("harStart", ¶ms).await
217 }
218
219 pub async fn har_export(&self, params: TracingHarExportParams) -> Result<TracingHarExportResult, ProtocolError> {
221 self.channel.send("harExport", ¶ms).await
222 }
223}