#[derive(Debug, Clone, serde::Serialize)]
pub struct DataReceivedParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "dataLength")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data_length: i64,
#[serde(rename = "encodedDataLength")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub encoded_data_length: i64,
#[serde(rename = "data")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub data: Option<String>,
}
impl<'de> serde::Deserialize<'de> for DataReceivedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DataReceivedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "dataLength")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data_length: i64,
#[serde(rename = "encodedDataLength")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub encoded_data_length: i64,
#[serde(rename = "data")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub data: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DataReceivedParams {
request_id: fields.request_id,
timestamp: fields.timestamp,
data_length: fields.data_length,
encoded_data_length: fields.encoded_data_length,
data: fields.data,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DataReceived;
impl ydp_core::Event for DataReceived {
type Params = DataReceivedParams;
const METHOD: &'static str = "Network.dataReceived";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DeviceBoundSessionEventOccurredParams {
#[serde(rename = "eventId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub event_id: crate::network::types::DeviceBoundSessionEventId,
#[serde(rename = "site")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub site: String,
#[serde(rename = "succeeded")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub succeeded: bool,
#[serde(rename = "sessionId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub session_id: Option<String>,
#[serde(rename = "creationEventDetails")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub creation_event_details: Option<crate::network::types::CreationEventDetails>,
#[serde(rename = "refreshEventDetails")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub refresh_event_details: Option<crate::network::types::RefreshEventDetails>,
#[serde(rename = "terminationEventDetails")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub termination_event_details: Option<crate::network::types::TerminationEventDetails>,
#[serde(rename = "challengeEventDetails")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub challenge_event_details: Option<crate::network::types::ChallengeEventDetails>,
}
impl<'de> serde::Deserialize<'de> for DeviceBoundSessionEventOccurredParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DeviceBoundSessionEventOccurredParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "eventId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub event_id: crate::network::types::DeviceBoundSessionEventId,
#[serde(rename = "site")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub site: String,
#[serde(rename = "succeeded")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub succeeded: bool,
#[serde(rename = "sessionId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub session_id: Option<String>,
#[serde(rename = "creationEventDetails")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub creation_event_details: Option<crate::network::types::CreationEventDetails>,
#[serde(rename = "refreshEventDetails")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub refresh_event_details: Option<crate::network::types::RefreshEventDetails>,
#[serde(rename = "terminationEventDetails")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub termination_event_details:
Option<crate::network::types::TerminationEventDetails>,
#[serde(rename = "challengeEventDetails")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub challenge_event_details:
Option<crate::network::types::ChallengeEventDetails>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DeviceBoundSessionEventOccurredParams {
event_id: fields.event_id,
site: fields.site,
succeeded: fields.succeeded,
session_id: fields.session_id,
creation_event_details: fields.creation_event_details,
refresh_event_details: fields.refresh_event_details,
termination_event_details: fields.termination_event_details,
challenge_event_details: fields.challenge_event_details,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DeviceBoundSessionEventOccurred;
impl ydp_core::Event for DeviceBoundSessionEventOccurred {
type Params = DeviceBoundSessionEventOccurredParams;
const METHOD: &'static str = "Network.deviceBoundSessionEventOccurred";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DeviceBoundSessionsAddedParams {
#[serde(rename = "sessions")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub sessions: Vec<crate::network::types::DeviceBoundSession>,
}
impl<'de> serde::Deserialize<'de> for DeviceBoundSessionsAddedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DeviceBoundSessionsAddedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "sessions")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub sessions: Vec<crate::network::types::DeviceBoundSession>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DeviceBoundSessionsAddedParams {
sessions: fields.sessions,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DeviceBoundSessionsAdded;
impl ydp_core::Event for DeviceBoundSessionsAdded {
type Params = DeviceBoundSessionsAddedParams;
const METHOD: &'static str = "Network.deviceBoundSessionsAdded";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DirectTcpSocketAbortedParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "errorMessage")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub error_message: crate::network::types::ErrorReason,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for DirectTcpSocketAbortedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DirectTcpSocketAbortedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "errorMessage")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub error_message: crate::network::types::ErrorReason,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DirectTcpSocketAbortedParams {
identifier: fields.identifier,
error_message: fields.error_message,
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DirectTcpSocketAborted;
impl ydp_core::Event for DirectTcpSocketAborted {
type Params = DirectTcpSocketAbortedParams;
const METHOD: &'static str = "Network.directTCPSocketAborted";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DirectTcpSocketChunkReceivedParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for DirectTcpSocketChunkReceivedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DirectTcpSocketChunkReceivedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DirectTcpSocketChunkReceivedParams {
identifier: fields.identifier,
data: fields.data,
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DirectTcpSocketChunkReceived;
impl ydp_core::Event for DirectTcpSocketChunkReceived {
type Params = DirectTcpSocketChunkReceivedParams;
const METHOD: &'static str = "Network.directTCPSocketChunkReceived";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DirectTcpSocketChunkSentParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for DirectTcpSocketChunkSentParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DirectTcpSocketChunkSentParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DirectTcpSocketChunkSentParams {
identifier: fields.identifier,
data: fields.data,
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DirectTcpSocketChunkSent;
impl ydp_core::Event for DirectTcpSocketChunkSent {
type Params = DirectTcpSocketChunkSentParams;
const METHOD: &'static str = "Network.directTCPSocketChunkSent";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DirectTcpSocketClosedParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for DirectTcpSocketClosedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DirectTcpSocketClosedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DirectTcpSocketClosedParams {
identifier: fields.identifier,
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DirectTcpSocketClosed;
impl ydp_core::Event for DirectTcpSocketClosed {
type Params = DirectTcpSocketClosedParams;
const METHOD: &'static str = "Network.directTCPSocketClosed";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DirectTcpSocketCreatedParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "remoteAddr")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub remote_addr: String,
#[serde(rename = "remotePort")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub remote_port: i64,
#[serde(rename = "options")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub options: crate::network::types::DirectTcpSocketOptions,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "initiator")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub initiator: Option<crate::network::types::Initiator>,
}
impl<'de> serde::Deserialize<'de> for DirectTcpSocketCreatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DirectTcpSocketCreatedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "remoteAddr")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub remote_addr: String,
#[serde(rename = "remotePort")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub remote_port: i64,
#[serde(rename = "options")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub options: crate::network::types::DirectTcpSocketOptions,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "initiator")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub initiator: Option<crate::network::types::Initiator>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DirectTcpSocketCreatedParams {
identifier: fields.identifier,
remote_addr: fields.remote_addr,
remote_port: fields.remote_port,
options: fields.options,
timestamp: fields.timestamp,
initiator: fields.initiator,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DirectTcpSocketCreated;
impl ydp_core::Event for DirectTcpSocketCreated {
type Params = DirectTcpSocketCreatedParams;
const METHOD: &'static str = "Network.directTCPSocketCreated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DirectTcpSocketOpenedParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "remoteAddr")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub remote_addr: String,
#[serde(rename = "remotePort")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub remote_port: i64,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "localAddr")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub local_addr: Option<String>,
#[serde(rename = "localPort")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub local_port: Option<i64>,
}
impl<'de> serde::Deserialize<'de> for DirectTcpSocketOpenedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DirectTcpSocketOpenedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "remoteAddr")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub remote_addr: String,
#[serde(rename = "remotePort")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub remote_port: i64,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "localAddr")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub local_addr: Option<String>,
#[serde(rename = "localPort")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub local_port: Option<i64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DirectTcpSocketOpenedParams {
identifier: fields.identifier,
remote_addr: fields.remote_addr,
remote_port: fields.remote_port,
timestamp: fields.timestamp,
local_addr: fields.local_addr,
local_port: fields.local_port,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DirectTcpSocketOpened;
impl ydp_core::Event for DirectTcpSocketOpened {
type Params = DirectTcpSocketOpenedParams;
const METHOD: &'static str = "Network.directTCPSocketOpened";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DirectUdpSocketAbortedParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "errorMessage")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub error_message: crate::network::types::ErrorReason,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for DirectUdpSocketAbortedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DirectUdpSocketAbortedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "errorMessage")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub error_message: crate::network::types::ErrorReason,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DirectUdpSocketAbortedParams {
identifier: fields.identifier,
error_message: fields.error_message,
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DirectUdpSocketAborted;
impl ydp_core::Event for DirectUdpSocketAborted {
type Params = DirectUdpSocketAbortedParams;
const METHOD: &'static str = "Network.directUDPSocketAborted";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DirectUdpSocketChunkReceivedParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "message")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub message: crate::network::types::DirectUdpMessage,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for DirectUdpSocketChunkReceivedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DirectUdpSocketChunkReceivedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "message")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub message: crate::network::types::DirectUdpMessage,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DirectUdpSocketChunkReceivedParams {
identifier: fields.identifier,
message: fields.message,
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DirectUdpSocketChunkReceived;
impl ydp_core::Event for DirectUdpSocketChunkReceived {
type Params = DirectUdpSocketChunkReceivedParams;
const METHOD: &'static str = "Network.directUDPSocketChunkReceived";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DirectUdpSocketChunkSentParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "message")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub message: crate::network::types::DirectUdpMessage,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for DirectUdpSocketChunkSentParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DirectUdpSocketChunkSentParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "message")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub message: crate::network::types::DirectUdpMessage,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DirectUdpSocketChunkSentParams {
identifier: fields.identifier,
message: fields.message,
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DirectUdpSocketChunkSent;
impl ydp_core::Event for DirectUdpSocketChunkSent {
type Params = DirectUdpSocketChunkSentParams;
const METHOD: &'static str = "Network.directUDPSocketChunkSent";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DirectUdpSocketClosedParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for DirectUdpSocketClosedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DirectUdpSocketClosedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DirectUdpSocketClosedParams {
identifier: fields.identifier,
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DirectUdpSocketClosed;
impl ydp_core::Event for DirectUdpSocketClosed {
type Params = DirectUdpSocketClosedParams;
const METHOD: &'static str = "Network.directUDPSocketClosed";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DirectUdpSocketCreatedParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "options")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub options: crate::network::types::DirectUdpSocketOptions,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "initiator")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub initiator: Option<crate::network::types::Initiator>,
}
impl<'de> serde::Deserialize<'de> for DirectUdpSocketCreatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DirectUdpSocketCreatedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "options")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub options: crate::network::types::DirectUdpSocketOptions,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "initiator")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub initiator: Option<crate::network::types::Initiator>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DirectUdpSocketCreatedParams {
identifier: fields.identifier,
options: fields.options,
timestamp: fields.timestamp,
initiator: fields.initiator,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DirectUdpSocketCreated;
impl ydp_core::Event for DirectUdpSocketCreated {
type Params = DirectUdpSocketCreatedParams;
const METHOD: &'static str = "Network.directUDPSocketCreated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DirectUdpSocketJoinedMulticastGroupParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "IPAddress")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub ip_address: String,
}
impl<'de> serde::Deserialize<'de> for DirectUdpSocketJoinedMulticastGroupParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DirectUdpSocketJoinedMulticastGroupParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "IPAddress")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub ip_address: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DirectUdpSocketJoinedMulticastGroupParams {
identifier: fields.identifier,
ip_address: fields.ip_address,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DirectUdpSocketJoinedMulticastGroup;
impl ydp_core::Event for DirectUdpSocketJoinedMulticastGroup {
type Params = DirectUdpSocketJoinedMulticastGroupParams;
const METHOD: &'static str = "Network.directUDPSocketJoinedMulticastGroup";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DirectUdpSocketLeftMulticastGroupParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "IPAddress")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub ip_address: String,
}
impl<'de> serde::Deserialize<'de> for DirectUdpSocketLeftMulticastGroupParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DirectUdpSocketLeftMulticastGroupParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "IPAddress")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub ip_address: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DirectUdpSocketLeftMulticastGroupParams {
identifier: fields.identifier,
ip_address: fields.ip_address,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DirectUdpSocketLeftMulticastGroup;
impl ydp_core::Event for DirectUdpSocketLeftMulticastGroup {
type Params = DirectUdpSocketLeftMulticastGroupParams;
const METHOD: &'static str = "Network.directUDPSocketLeftMulticastGroup";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DirectUdpSocketOpenedParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "localAddr")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub local_addr: String,
#[serde(rename = "localPort")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub local_port: i64,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "remoteAddr")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub remote_addr: Option<String>,
#[serde(rename = "remotePort")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub remote_port: Option<i64>,
}
impl<'de> serde::Deserialize<'de> for DirectUdpSocketOpenedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DirectUdpSocketOpenedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::network::types::RequestId,
#[serde(rename = "localAddr")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub local_addr: String,
#[serde(rename = "localPort")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub local_port: i64,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "remoteAddr")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub remote_addr: Option<String>,
#[serde(rename = "remotePort")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub remote_port: Option<i64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DirectUdpSocketOpenedParams {
identifier: fields.identifier,
local_addr: fields.local_addr,
local_port: fields.local_port,
timestamp: fields.timestamp,
remote_addr: fields.remote_addr,
remote_port: fields.remote_port,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DirectUdpSocketOpened;
impl ydp_core::Event for DirectUdpSocketOpened {
type Params = DirectUdpSocketOpenedParams;
const METHOD: &'static str = "Network.directUDPSocketOpened";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct EventSourceMessageReceivedParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "eventName")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub event_name: String,
#[serde(rename = "eventId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub event_id: String,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
}
impl<'de> serde::Deserialize<'de> for EventSourceMessageReceivedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = EventSourceMessageReceivedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "eventName")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub event_name: String,
#[serde(rename = "eventId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub event_id: String,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(EventSourceMessageReceivedParams {
request_id: fields.request_id,
timestamp: fields.timestamp,
event_name: fields.event_name,
event_id: fields.event_id,
data: fields.data,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct EventSourceMessageReceived;
impl ydp_core::Event for EventSourceMessageReceived {
type Params = EventSourceMessageReceivedParams;
const METHOD: &'static str = "Network.eventSourceMessageReceived";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct LoadingFailedParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::network::types::ResourceType,
#[serde(rename = "errorText")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub error_text: String,
#[serde(rename = "canceled")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub canceled: Option<bool>,
#[serde(rename = "blockedReason")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub blocked_reason: Option<crate::network::types::BlockedReason>,
#[serde(rename = "corsErrorStatus")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub cors_error_status: Option<crate::network::types::CorsErrorStatus>,
}
impl<'de> serde::Deserialize<'de> for LoadingFailedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = LoadingFailedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::network::types::ResourceType,
#[serde(rename = "errorText")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub error_text: String,
#[serde(rename = "canceled")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub canceled: Option<bool>,
#[serde(rename = "blockedReason")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub blocked_reason: Option<crate::network::types::BlockedReason>,
#[serde(rename = "corsErrorStatus")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub cors_error_status: Option<crate::network::types::CorsErrorStatus>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(LoadingFailedParams {
request_id: fields.request_id,
timestamp: fields.timestamp,
r#type: fields.r#type,
error_text: fields.error_text,
canceled: fields.canceled,
blocked_reason: fields.blocked_reason,
cors_error_status: fields.cors_error_status,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct LoadingFailed;
impl ydp_core::Event for LoadingFailed {
type Params = LoadingFailedParams;
const METHOD: &'static str = "Network.loadingFailed";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct LoadingFinishedParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "encodedDataLength")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub encoded_data_length: ydp_core::FiniteF64,
}
impl<'de> serde::Deserialize<'de> for LoadingFinishedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = LoadingFinishedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "encodedDataLength")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub encoded_data_length: ydp_core::FiniteF64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(LoadingFinishedParams {
request_id: fields.request_id,
timestamp: fields.timestamp,
encoded_data_length: fields.encoded_data_length,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct LoadingFinished;
impl ydp_core::Event for LoadingFinished {
type Params = LoadingFinishedParams;
const METHOD: &'static str = "Network.loadingFinished";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct PolicyUpdatedParams {}
impl<'de> serde::Deserialize<'de> for PolicyUpdatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PolicyUpdatedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PolicyUpdatedParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct PolicyUpdated;
impl ydp_core::Event for PolicyUpdated {
type Params = PolicyUpdatedParams;
const METHOD: &'static str = "Network.policyUpdated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ReportingApiEndpointsChangedForOriginParams {
#[serde(rename = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
#[serde(rename = "endpoints")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub endpoints: Vec<crate::network::types::ReportingApiEndpoint>,
}
impl<'de> serde::Deserialize<'de> for ReportingApiEndpointsChangedForOriginParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ReportingApiEndpointsChangedForOriginParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
#[serde(rename = "endpoints")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub endpoints: Vec<crate::network::types::ReportingApiEndpoint>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ReportingApiEndpointsChangedForOriginParams {
origin: fields.origin,
endpoints: fields.endpoints,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ReportingApiEndpointsChangedForOrigin;
impl ydp_core::Event for ReportingApiEndpointsChangedForOrigin {
type Params = ReportingApiEndpointsChangedForOriginParams;
const METHOD: &'static str = "Network.reportingApiEndpointsChangedForOrigin";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ReportingApiReportAddedParams {
#[serde(rename = "report")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub report: crate::network::types::ReportingApiReport,
}
impl<'de> serde::Deserialize<'de> for ReportingApiReportAddedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ReportingApiReportAddedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "report")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub report: crate::network::types::ReportingApiReport,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ReportingApiReportAddedParams {
report: fields.report,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ReportingApiReportAdded;
impl ydp_core::Event for ReportingApiReportAdded {
type Params = ReportingApiReportAddedParams;
const METHOD: &'static str = "Network.reportingApiReportAdded";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ReportingApiReportUpdatedParams {
#[serde(rename = "report")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub report: crate::network::types::ReportingApiReport,
}
impl<'de> serde::Deserialize<'de> for ReportingApiReportUpdatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ReportingApiReportUpdatedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "report")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub report: crate::network::types::ReportingApiReport,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ReportingApiReportUpdatedParams {
report: fields.report,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ReportingApiReportUpdated;
impl ydp_core::Event for ReportingApiReportUpdated {
type Params = ReportingApiReportUpdatedParams;
const METHOD: &'static str = "Network.reportingApiReportUpdated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RequestServedFromCacheParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
}
impl<'de> serde::Deserialize<'de> for RequestServedFromCacheParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RequestServedFromCacheParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RequestServedFromCacheParams {
request_id: fields.request_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RequestServedFromCache;
impl ydp_core::Event for RequestServedFromCache {
type Params = RequestServedFromCacheParams;
const METHOD: &'static str = "Network.requestServedFromCache";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RequestWillBeSentParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "loaderId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub loader_id: crate::network::types::LoaderId,
#[serde(rename = "documentURL")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub document_url: String,
#[serde(rename = "request")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request: crate::network::types::Request,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "wallTime")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub wall_time: crate::network::types::TimeSinceEpoch,
#[serde(rename = "initiator")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub initiator: crate::network::types::Initiator,
#[serde(rename = "redirectHasExtraInfo")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub redirect_has_extra_info: bool,
#[serde(rename = "redirectResponse")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub redirect_response: Option<crate::network::types::Response>,
#[serde(rename = "type")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub r#type: Option<crate::network::types::ResourceType>,
#[serde(rename = "frameId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub frame_id: Option<crate::page::types::FrameId>,
#[serde(rename = "hasUserGesture")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub has_user_gesture: Option<bool>,
#[serde(rename = "renderBlockingBehavior")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub render_blocking_behavior: Option<crate::network::types::RenderBlockingBehavior>,
}
impl<'de> serde::Deserialize<'de> for RequestWillBeSentParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RequestWillBeSentParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "loaderId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub loader_id: crate::network::types::LoaderId,
#[serde(rename = "documentURL")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub document_url: String,
#[serde(rename = "request")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request: crate::network::types::Request,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "wallTime")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub wall_time: crate::network::types::TimeSinceEpoch,
#[serde(rename = "initiator")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub initiator: crate::network::types::Initiator,
#[serde(rename = "redirectHasExtraInfo")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub redirect_has_extra_info: bool,
#[serde(rename = "redirectResponse")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub redirect_response: Option<crate::network::types::Response>,
#[serde(rename = "type")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub r#type: Option<crate::network::types::ResourceType>,
#[serde(rename = "frameId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub frame_id: Option<crate::page::types::FrameId>,
#[serde(rename = "hasUserGesture")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub has_user_gesture: Option<bool>,
#[serde(rename = "renderBlockingBehavior")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub render_blocking_behavior:
Option<crate::network::types::RenderBlockingBehavior>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RequestWillBeSentParams {
request_id: fields.request_id,
loader_id: fields.loader_id,
document_url: fields.document_url,
request: fields.request,
timestamp: fields.timestamp,
wall_time: fields.wall_time,
initiator: fields.initiator,
redirect_has_extra_info: fields.redirect_has_extra_info,
redirect_response: fields.redirect_response,
r#type: fields.r#type,
frame_id: fields.frame_id,
has_user_gesture: fields.has_user_gesture,
render_blocking_behavior: fields.render_blocking_behavior,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RequestWillBeSent;
impl ydp_core::Event for RequestWillBeSent {
type Params = RequestWillBeSentParams;
const METHOD: &'static str = "Network.requestWillBeSent";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RequestWillBeSentExtraInfoParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "associatedCookies")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub associated_cookies: Vec<crate::network::types::AssociatedCookie>,
#[serde(rename = "headers")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub headers: crate::network::types::Headers,
#[serde(rename = "connectTiming")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub connect_timing: crate::network::types::ConnectTiming,
#[serde(rename = "deviceBoundSessionUsages")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub device_bound_session_usages:
Option<Vec<crate::network::types::DeviceBoundSessionWithUsage>>,
#[serde(rename = "clientSecurityState")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub client_security_state: Option<crate::network::types::ClientSecurityState>,
#[serde(rename = "siteHasCookieInOtherPartition")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub site_has_cookie_in_other_partition: Option<bool>,
#[serde(rename = "appliedNetworkConditionsId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub applied_network_conditions_id: Option<String>,
}
impl<'de> serde::Deserialize<'de> for RequestWillBeSentExtraInfoParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RequestWillBeSentExtraInfoParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "associatedCookies")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub associated_cookies: Vec<crate::network::types::AssociatedCookie>,
#[serde(rename = "headers")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub headers: crate::network::types::Headers,
#[serde(rename = "connectTiming")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub connect_timing: crate::network::types::ConnectTiming,
#[serde(rename = "deviceBoundSessionUsages")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub device_bound_session_usages:
Option<Vec<crate::network::types::DeviceBoundSessionWithUsage>>,
#[serde(rename = "clientSecurityState")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub client_security_state: Option<crate::network::types::ClientSecurityState>,
#[serde(rename = "siteHasCookieInOtherPartition")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub site_has_cookie_in_other_partition: Option<bool>,
#[serde(rename = "appliedNetworkConditionsId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub applied_network_conditions_id: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RequestWillBeSentExtraInfoParams {
request_id: fields.request_id,
associated_cookies: fields.associated_cookies,
headers: fields.headers,
connect_timing: fields.connect_timing,
device_bound_session_usages: fields.device_bound_session_usages,
client_security_state: fields.client_security_state,
site_has_cookie_in_other_partition: fields.site_has_cookie_in_other_partition,
applied_network_conditions_id: fields.applied_network_conditions_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RequestWillBeSentExtraInfo;
impl ydp_core::Event for RequestWillBeSentExtraInfo {
type Params = RequestWillBeSentExtraInfoParams;
const METHOD: &'static str = "Network.requestWillBeSentExtraInfo";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ResourceChangedPriorityParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "newPriority")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub new_priority: crate::network::types::ResourcePriority,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for ResourceChangedPriorityParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResourceChangedPriorityParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "newPriority")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub new_priority: crate::network::types::ResourcePriority,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ResourceChangedPriorityParams {
request_id: fields.request_id,
new_priority: fields.new_priority,
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ResourceChangedPriority;
impl ydp_core::Event for ResourceChangedPriority {
type Params = ResourceChangedPriorityParams;
const METHOD: &'static str = "Network.resourceChangedPriority";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ResponseReceivedParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "loaderId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub loader_id: crate::network::types::LoaderId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::network::types::ResourceType,
#[serde(rename = "response")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub response: crate::network::types::Response,
#[serde(rename = "hasExtraInfo")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub has_extra_info: bool,
#[serde(rename = "frameId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub frame_id: Option<crate::page::types::FrameId>,
}
impl<'de> serde::Deserialize<'de> for ResponseReceivedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResponseReceivedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "loaderId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub loader_id: crate::network::types::LoaderId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::network::types::ResourceType,
#[serde(rename = "response")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub response: crate::network::types::Response,
#[serde(rename = "hasExtraInfo")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub has_extra_info: bool,
#[serde(rename = "frameId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub frame_id: Option<crate::page::types::FrameId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ResponseReceivedParams {
request_id: fields.request_id,
loader_id: fields.loader_id,
timestamp: fields.timestamp,
r#type: fields.r#type,
response: fields.response,
has_extra_info: fields.has_extra_info,
frame_id: fields.frame_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ResponseReceived;
impl ydp_core::Event for ResponseReceived {
type Params = ResponseReceivedParams;
const METHOD: &'static str = "Network.responseReceived";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ResponseReceivedEarlyHintsParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "headers")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub headers: crate::network::types::Headers,
}
impl<'de> serde::Deserialize<'de> for ResponseReceivedEarlyHintsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResponseReceivedEarlyHintsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "headers")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub headers: crate::network::types::Headers,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ResponseReceivedEarlyHintsParams {
request_id: fields.request_id,
headers: fields.headers,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ResponseReceivedEarlyHints;
impl ydp_core::Event for ResponseReceivedEarlyHints {
type Params = ResponseReceivedEarlyHintsParams;
const METHOD: &'static str = "Network.responseReceivedEarlyHints";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ResponseReceivedExtraInfoParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "blockedCookies")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub blocked_cookies: Vec<crate::network::types::BlockedSetCookieWithReason>,
#[serde(rename = "headers")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub headers: crate::network::types::Headers,
#[serde(rename = "resourceIPAddressSpace")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub resource_ip_address_space: crate::network::types::IpAddressSpace,
#[serde(rename = "statusCode")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub status_code: i64,
#[serde(rename = "headersText")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub headers_text: Option<String>,
#[serde(rename = "cookiePartitionKey")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub cookie_partition_key: Option<crate::network::types::CookiePartitionKey>,
#[serde(rename = "cookiePartitionKeyOpaque")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub cookie_partition_key_opaque: Option<bool>,
#[serde(rename = "exemptedCookies")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub exempted_cookies: Option<Vec<crate::network::types::ExemptedSetCookieWithReason>>,
}
impl<'de> serde::Deserialize<'de> for ResponseReceivedExtraInfoParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResponseReceivedExtraInfoParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "blockedCookies")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub blocked_cookies: Vec<crate::network::types::BlockedSetCookieWithReason>,
#[serde(rename = "headers")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub headers: crate::network::types::Headers,
#[serde(rename = "resourceIPAddressSpace")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub resource_ip_address_space: crate::network::types::IpAddressSpace,
#[serde(rename = "statusCode")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub status_code: i64,
#[serde(rename = "headersText")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub headers_text: Option<String>,
#[serde(rename = "cookiePartitionKey")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub cookie_partition_key: Option<crate::network::types::CookiePartitionKey>,
#[serde(rename = "cookiePartitionKeyOpaque")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub cookie_partition_key_opaque: Option<bool>,
#[serde(rename = "exemptedCookies")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub exempted_cookies:
Option<Vec<crate::network::types::ExemptedSetCookieWithReason>>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ResponseReceivedExtraInfoParams {
request_id: fields.request_id,
blocked_cookies: fields.blocked_cookies,
headers: fields.headers,
resource_ip_address_space: fields.resource_ip_address_space,
status_code: fields.status_code,
headers_text: fields.headers_text,
cookie_partition_key: fields.cookie_partition_key,
cookie_partition_key_opaque: fields.cookie_partition_key_opaque,
exempted_cookies: fields.exempted_cookies,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ResponseReceivedExtraInfo;
impl ydp_core::Event for ResponseReceivedExtraInfo {
type Params = ResponseReceivedExtraInfoParams;
const METHOD: &'static str = "Network.responseReceivedExtraInfo";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SignedExchangeReceivedParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "info")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub info: crate::network::types::SignedExchangeInfo,
}
impl<'de> serde::Deserialize<'de> for SignedExchangeReceivedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SignedExchangeReceivedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "info")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub info: crate::network::types::SignedExchangeInfo,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SignedExchangeReceivedParams {
request_id: fields.request_id,
info: fields.info,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SignedExchangeReceived;
impl ydp_core::Event for SignedExchangeReceived {
type Params = SignedExchangeReceivedParams;
const METHOD: &'static str = "Network.signedExchangeReceived";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum TrustTokenOperationDoneParamsStatus {
Ok,
InvalidArgument,
MissingIssuerKeys,
FailedPrecondition,
ResourceExhausted,
AlreadyExists,
ResourceLimited,
Unauthorized,
BadResponse,
InternalError,
UnknownError,
FulfilledLocally,
SiteIssuerLimit,
Unknown(String),
}
impl TrustTokenOperationDoneParamsStatus {
pub fn as_str(&self) -> &str {
match self {
Self::Ok => "Ok",
Self::InvalidArgument => "InvalidArgument",
Self::MissingIssuerKeys => "MissingIssuerKeys",
Self::FailedPrecondition => "FailedPrecondition",
Self::ResourceExhausted => "ResourceExhausted",
Self::AlreadyExists => "AlreadyExists",
Self::ResourceLimited => "ResourceLimited",
Self::Unauthorized => "Unauthorized",
Self::BadResponse => "BadResponse",
Self::InternalError => "InternalError",
Self::UnknownError => "UnknownError",
Self::FulfilledLocally => "FulfilledLocally",
Self::SiteIssuerLimit => "SiteIssuerLimit",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for TrustTokenOperationDoneParamsStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for TrustTokenOperationDoneParamsStatus {
fn from(value: String) -> Self {
match value.as_str() {
"Ok" => TrustTokenOperationDoneParamsStatus::Ok,
"InvalidArgument" => TrustTokenOperationDoneParamsStatus::InvalidArgument,
"MissingIssuerKeys" => TrustTokenOperationDoneParamsStatus::MissingIssuerKeys,
"FailedPrecondition" => TrustTokenOperationDoneParamsStatus::FailedPrecondition,
"ResourceExhausted" => TrustTokenOperationDoneParamsStatus::ResourceExhausted,
"AlreadyExists" => TrustTokenOperationDoneParamsStatus::AlreadyExists,
"ResourceLimited" => TrustTokenOperationDoneParamsStatus::ResourceLimited,
"Unauthorized" => TrustTokenOperationDoneParamsStatus::Unauthorized,
"BadResponse" => TrustTokenOperationDoneParamsStatus::BadResponse,
"InternalError" => TrustTokenOperationDoneParamsStatus::InternalError,
"UnknownError" => TrustTokenOperationDoneParamsStatus::UnknownError,
"FulfilledLocally" => TrustTokenOperationDoneParamsStatus::FulfilledLocally,
"SiteIssuerLimit" => TrustTokenOperationDoneParamsStatus::SiteIssuerLimit,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for TrustTokenOperationDoneParamsStatus {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for TrustTokenOperationDoneParamsStatus {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TrustTokenOperationDoneParamsStatus;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议字符串枚举")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
Ok(match v {
"Ok" => TrustTokenOperationDoneParamsStatus::Ok,
"InvalidArgument" => TrustTokenOperationDoneParamsStatus::InvalidArgument,
"MissingIssuerKeys" => TrustTokenOperationDoneParamsStatus::MissingIssuerKeys,
"FailedPrecondition" => TrustTokenOperationDoneParamsStatus::FailedPrecondition,
"ResourceExhausted" => TrustTokenOperationDoneParamsStatus::ResourceExhausted,
"AlreadyExists" => TrustTokenOperationDoneParamsStatus::AlreadyExists,
"ResourceLimited" => TrustTokenOperationDoneParamsStatus::ResourceLimited,
"Unauthorized" => TrustTokenOperationDoneParamsStatus::Unauthorized,
"BadResponse" => TrustTokenOperationDoneParamsStatus::BadResponse,
"InternalError" => TrustTokenOperationDoneParamsStatus::InternalError,
"UnknownError" => TrustTokenOperationDoneParamsStatus::UnknownError,
"FulfilledLocally" => TrustTokenOperationDoneParamsStatus::FulfilledLocally,
"SiteIssuerLimit" => TrustTokenOperationDoneParamsStatus::SiteIssuerLimit,
_ => TrustTokenOperationDoneParamsStatus::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(TrustTokenOperationDoneParamsStatus::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct TrustTokenOperationDoneParams {
#[serde(rename = "status")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub status: TrustTokenOperationDoneParamsStatus,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::network::types::TrustTokenOperationType,
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "topLevelOrigin")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub top_level_origin: Option<String>,
#[serde(rename = "issuerOrigin")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub issuer_origin: Option<String>,
#[serde(rename = "issuedTokenCount")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub issued_token_count: Option<i64>,
}
impl<'de> serde::Deserialize<'de> for TrustTokenOperationDoneParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TrustTokenOperationDoneParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "status")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub status: TrustTokenOperationDoneParamsStatus,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::network::types::TrustTokenOperationType,
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "topLevelOrigin")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub top_level_origin: Option<String>,
#[serde(rename = "issuerOrigin")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub issuer_origin: Option<String>,
#[serde(rename = "issuedTokenCount")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub issued_token_count: Option<i64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(TrustTokenOperationDoneParams {
status: fields.status,
r#type: fields.r#type,
request_id: fields.request_id,
top_level_origin: fields.top_level_origin,
issuer_origin: fields.issuer_origin,
issued_token_count: fields.issued_token_count,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct TrustTokenOperationDone;
impl ydp_core::Event for TrustTokenOperationDone {
type Params = TrustTokenOperationDoneParams;
const METHOD: &'static str = "Network.trustTokenOperationDone";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct WebSocketClosedParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for WebSocketClosedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = WebSocketClosedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(WebSocketClosedParams {
request_id: fields.request_id,
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct WebSocketClosed;
impl ydp_core::Event for WebSocketClosed {
type Params = WebSocketClosedParams;
const METHOD: &'static str = "Network.webSocketClosed";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct WebSocketCreatedParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "initiator")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub initiator: Option<crate::network::types::Initiator>,
}
impl<'de> serde::Deserialize<'de> for WebSocketCreatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = WebSocketCreatedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "initiator")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub initiator: Option<crate::network::types::Initiator>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(WebSocketCreatedParams {
request_id: fields.request_id,
url: fields.url,
initiator: fields.initiator,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct WebSocketCreated;
impl ydp_core::Event for WebSocketCreated {
type Params = WebSocketCreatedParams;
const METHOD: &'static str = "Network.webSocketCreated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct WebSocketFrameErrorParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "errorMessage")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub error_message: String,
}
impl<'de> serde::Deserialize<'de> for WebSocketFrameErrorParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = WebSocketFrameErrorParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "errorMessage")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub error_message: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(WebSocketFrameErrorParams {
request_id: fields.request_id,
timestamp: fields.timestamp,
error_message: fields.error_message,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct WebSocketFrameError;
impl ydp_core::Event for WebSocketFrameError {
type Params = WebSocketFrameErrorParams;
const METHOD: &'static str = "Network.webSocketFrameError";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct WebSocketFrameReceivedParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "response")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub response: crate::network::types::WebSocketFrame,
}
impl<'de> serde::Deserialize<'de> for WebSocketFrameReceivedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = WebSocketFrameReceivedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "response")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub response: crate::network::types::WebSocketFrame,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(WebSocketFrameReceivedParams {
request_id: fields.request_id,
timestamp: fields.timestamp,
response: fields.response,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct WebSocketFrameReceived;
impl ydp_core::Event for WebSocketFrameReceived {
type Params = WebSocketFrameReceivedParams;
const METHOD: &'static str = "Network.webSocketFrameReceived";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct WebSocketFrameSentParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "response")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub response: crate::network::types::WebSocketFrame,
}
impl<'de> serde::Deserialize<'de> for WebSocketFrameSentParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = WebSocketFrameSentParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "response")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub response: crate::network::types::WebSocketFrame,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(WebSocketFrameSentParams {
request_id: fields.request_id,
timestamp: fields.timestamp,
response: fields.response,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct WebSocketFrameSent;
impl ydp_core::Event for WebSocketFrameSent {
type Params = WebSocketFrameSentParams;
const METHOD: &'static str = "Network.webSocketFrameSent";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct WebSocketHandshakeResponseReceivedParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "response")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub response: crate::network::types::WebSocketResponse,
}
impl<'de> serde::Deserialize<'de> for WebSocketHandshakeResponseReceivedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = WebSocketHandshakeResponseReceivedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "response")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub response: crate::network::types::WebSocketResponse,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(WebSocketHandshakeResponseReceivedParams {
request_id: fields.request_id,
timestamp: fields.timestamp,
response: fields.response,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct WebSocketHandshakeResponseReceived;
impl ydp_core::Event for WebSocketHandshakeResponseReceived {
type Params = WebSocketHandshakeResponseReceivedParams;
const METHOD: &'static str = "Network.webSocketHandshakeResponseReceived";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct WebSocketWillSendHandshakeRequestParams {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "wallTime")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub wall_time: crate::network::types::TimeSinceEpoch,
#[serde(rename = "request")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request: crate::network::types::WebSocketRequest,
}
impl<'de> serde::Deserialize<'de> for WebSocketWillSendHandshakeRequestParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = WebSocketWillSendHandshakeRequestParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "requestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "wallTime")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub wall_time: crate::network::types::TimeSinceEpoch,
#[serde(rename = "request")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request: crate::network::types::WebSocketRequest,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(WebSocketWillSendHandshakeRequestParams {
request_id: fields.request_id,
timestamp: fields.timestamp,
wall_time: fields.wall_time,
request: fields.request,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct WebSocketWillSendHandshakeRequest;
impl ydp_core::Event for WebSocketWillSendHandshakeRequest {
type Params = WebSocketWillSendHandshakeRequestParams;
const METHOD: &'static str = "Network.webSocketWillSendHandshakeRequest";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct WebTransportClosedParams {
#[serde(rename = "transportId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub transport_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for WebTransportClosedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = WebTransportClosedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "transportId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub transport_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(WebTransportClosedParams {
transport_id: fields.transport_id,
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct WebTransportClosed;
impl ydp_core::Event for WebTransportClosed {
type Params = WebTransportClosedParams;
const METHOD: &'static str = "Network.webTransportClosed";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct WebTransportConnectionEstablishedParams {
#[serde(rename = "transportId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub transport_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for WebTransportConnectionEstablishedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = WebTransportConnectionEstablishedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "transportId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub transport_id: crate::network::types::RequestId,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(WebTransportConnectionEstablishedParams {
transport_id: fields.transport_id,
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct WebTransportConnectionEstablished;
impl ydp_core::Event for WebTransportConnectionEstablished {
type Params = WebTransportConnectionEstablishedParams;
const METHOD: &'static str = "Network.webTransportConnectionEstablished";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct WebTransportCreatedParams {
#[serde(rename = "transportId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub transport_id: crate::network::types::RequestId,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "initiator")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub initiator: Option<crate::network::types::Initiator>,
}
impl<'de> serde::Deserialize<'de> for WebTransportCreatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = WebTransportCreatedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "transportId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub transport_id: crate::network::types::RequestId,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
#[serde(rename = "initiator")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub initiator: Option<crate::network::types::Initiator>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(WebTransportCreatedParams {
transport_id: fields.transport_id,
url: fields.url,
timestamp: fields.timestamp,
initiator: fields.initiator,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct WebTransportCreated;
impl ydp_core::Event for WebTransportCreated {
type Params = WebTransportCreatedParams;
const METHOD: &'static str = "Network.webTransportCreated";
}