Skip to main content

browser_commander/playwright/protocol/
web_socket_route.rs

1// @generated by scripts/generate-playwright-protocol.mjs from
2// rust/protocol/playwright/*.yml. Do not edit by hand.
3
4#![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/// Initializer the driver sends when it creates a `WebSocketRoute`.
14#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
15pub struct WebSocketRouteInitializer {
16    #[serde(rename = "url")]
17    pub url: String,
18    #[serde(rename = "protocols")]
19    pub protocols: Vec<String>,
20}
21
22/// Parameters of `WebSocketRoute.sendToPage` (Send WebSocket message).
23#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
24pub struct WebSocketRouteSendToPageParams {
25    #[serde(rename = "message")]
26    pub message: String,
27    #[serde(rename = "isBase64")]
28    pub is_base64: bool,
29}
30
31/// Parameters of `WebSocketRoute.sendToServer` (Send WebSocket message).
32#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
33pub struct WebSocketRouteSendToServerParams {
34    #[serde(rename = "message")]
35    pub message: String,
36    #[serde(rename = "isBase64")]
37    pub is_base64: bool,
38}
39
40/// Parameters of `WebSocketRoute.closePage`.
41#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
42pub struct WebSocketRouteClosePageParams {
43    #[serde(rename = "code", default, skip_serializing_if = "Option::is_none")]
44    pub code: Option<i64>,
45    #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
46    pub reason: Option<String>,
47    #[serde(rename = "wasClean")]
48    pub was_clean: bool,
49}
50
51/// Parameters of `WebSocketRoute.closeServer`.
52#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
53pub struct WebSocketRouteCloseServerParams {
54    #[serde(rename = "code", default, skip_serializing_if = "Option::is_none")]
55    pub code: Option<i64>,
56    #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
57    pub reason: Option<String>,
58    #[serde(rename = "wasClean")]
59    pub was_clean: bool,
60}
61
62/// Payload of the `WebSocketRoute.messageFromPage` event.
63#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
64pub struct WebSocketRouteMessageFromPageEventParams {
65    #[serde(rename = "message")]
66    pub message: String,
67    #[serde(rename = "isBase64")]
68    pub is_base64: bool,
69}
70
71/// Payload of the `WebSocketRoute.messageFromServer` event.
72#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
73pub struct WebSocketRouteMessageFromServerEventParams {
74    #[serde(rename = "message")]
75    pub message: String,
76    #[serde(rename = "isBase64")]
77    pub is_base64: bool,
78}
79
80/// Payload of the `WebSocketRoute.closePage` event.
81#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
82pub struct WebSocketRouteClosePageEventParams {
83    #[serde(rename = "code", default, skip_serializing_if = "Option::is_none")]
84    pub code: Option<i64>,
85    #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
86    pub reason: Option<String>,
87    #[serde(rename = "wasClean")]
88    pub was_clean: bool,
89}
90
91/// Payload of the `WebSocketRoute.closeServer` event.
92#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
93pub struct WebSocketRouteCloseServerEventParams {
94    #[serde(rename = "code", default, skip_serializing_if = "Option::is_none")]
95    pub code: Option<i64>,
96    #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
97    pub reason: Option<String>,
98    #[serde(rename = "wasClean")]
99    pub was_clean: bool,
100}
101
102/// Events a `WebSocketRoute` channel can emit.
103#[derive(Debug, Clone, PartialEq)]
104pub enum WebSocketRouteEvent {
105    /// `WebSocketRoute.messageFromPage`
106    MessageFromPage(WebSocketRouteMessageFromPageEventParams),
107    /// `WebSocketRoute.messageFromServer`
108    MessageFromServer(WebSocketRouteMessageFromServerEventParams),
109    /// `WebSocketRoute.closePage`
110    ClosePage(WebSocketRouteClosePageEventParams),
111    /// `WebSocketRoute.closeServer`
112    CloseServer(WebSocketRouteCloseServerEventParams),
113    /// An event this binding does not know (a newer driver).
114    Unknown {
115        /// Event name.
116        method: String,
117        /// Raw event parameters.
118        params: serde_json::Value,
119    },
120}
121
122impl ProtocolEvent for WebSocketRouteEvent {
123    fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
124        match method {
125            "messageFromPage" => Ok(Self::MessageFromPage(serde_json::from_value(params)?)),
126            "messageFromServer" => Ok(Self::MessageFromServer(serde_json::from_value(params)?)),
127            "closePage" => Ok(Self::ClosePage(serde_json::from_value(params)?)),
128            "closeServer" => Ok(Self::CloseServer(serde_json::from_value(params)?)),
129            _ => Ok(Self::Unknown { method: method.to_string(), params }),
130        }
131    }
132}
133
134/// Channel for the `WebSocketRoute` interface (`network.yml`).
135#[derive(Debug, Clone)]
136pub struct WebSocketRoute {
137    channel: Channel,
138}
139
140impl ChannelType for WebSocketRoute {
141    const INTERFACE: &'static str = "WebSocketRoute";
142    type Initializer = WebSocketRouteInitializer;
143    type Event = WebSocketRouteEvent;
144
145    fn accepts(interface: &str) -> bool {
146        matches!(interface, "WebSocketRoute")
147    }
148
149    fn from_channel(channel: Channel) -> Self {
150        Self { channel }
151    }
152
153    fn channel(&self) -> &Channel {
154        &self.channel
155    }
156}
157
158impl WebSocketRoute {
159    /// `WebSocketRoute.connect` ("Connect WebSocket to server").
160    pub async fn connect(&self) -> Result<(), ProtocolError> {
161        self.channel.send_no_result("connect", &serde_json::json!({})).await
162    }
163
164    /// `WebSocketRoute.ensureOpened` (internal).
165    pub async fn ensure_opened(&self) -> Result<(), ProtocolError> {
166        self.channel.send_no_result("ensureOpened", &serde_json::json!({})).await
167    }
168
169    /// `WebSocketRoute.sendToPage` ("Send WebSocket message").
170    pub async fn send_to_page(&self, params: WebSocketRouteSendToPageParams) -> Result<(), ProtocolError> {
171        self.channel.send_no_result("sendToPage", &params).await
172    }
173
174    /// `WebSocketRoute.sendToServer` ("Send WebSocket message").
175    pub async fn send_to_server(&self, params: WebSocketRouteSendToServerParams) -> Result<(), ProtocolError> {
176        self.channel.send_no_result("sendToServer", &params).await
177    }
178
179    /// `WebSocketRoute.closePage` (internal).
180    pub async fn close_page(&self, params: WebSocketRouteClosePageParams) -> Result<(), ProtocolError> {
181        self.channel.send_no_result("closePage", &params).await
182    }
183
184    /// `WebSocketRoute.closeServer` (internal).
185    pub async fn close_server(&self, params: WebSocketRouteCloseServerParams) -> Result<(), ProtocolError> {
186        self.channel.send_no_result("closeServer", &params).await
187    }
188}