#[derive(Debug, Clone, serde::Serialize)]
pub struct BackForwardCacheNotUsedParams {
#[serde(rename = "loaderId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub loader_id: crate::network::types::LoaderId,
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "notRestoredExplanations")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub not_restored_explanations: Vec<crate::page::types::BackForwardCacheNotRestoredExplanation>,
#[serde(rename = "notRestoredExplanationsTree")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub not_restored_explanations_tree:
Option<crate::page::types::BackForwardCacheNotRestoredExplanationTree>,
}
impl<'de> serde::Deserialize<'de> for BackForwardCacheNotUsedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = BackForwardCacheNotUsedParams;
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 = "loaderId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub loader_id: crate::network::types::LoaderId,
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "notRestoredExplanations")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub not_restored_explanations:
Vec<crate::page::types::BackForwardCacheNotRestoredExplanation>,
#[serde(rename = "notRestoredExplanationsTree")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub not_restored_explanations_tree:
Option<crate::page::types::BackForwardCacheNotRestoredExplanationTree>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(BackForwardCacheNotUsedParams {
loader_id: fields.loader_id,
frame_id: fields.frame_id,
not_restored_explanations: fields.not_restored_explanations,
not_restored_explanations_tree: fields.not_restored_explanations_tree,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct BackForwardCacheNotUsed;
impl ydp_core::Event for BackForwardCacheNotUsed {
type Params = BackForwardCacheNotUsedParams;
const METHOD: &'static str = "Page.backForwardCacheNotUsed";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct CompilationCacheProducedParams {
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
}
impl<'de> serde::Deserialize<'de> for CompilationCacheProducedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CompilationCacheProducedParams;
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 = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: 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(CompilationCacheProducedParams {
url: fields.url,
data: fields.data,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct CompilationCacheProduced;
impl ydp_core::Event for CompilationCacheProduced {
type Params = CompilationCacheProducedParams;
const METHOD: &'static str = "Page.compilationCacheProduced";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DocumentOpenedParams {
#[serde(rename = "frame")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame: crate::page::types::Frame,
}
impl<'de> serde::Deserialize<'de> for DocumentOpenedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DocumentOpenedParams;
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 = "frame")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame: crate::page::types::Frame,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DocumentOpenedParams {
frame: fields.frame,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DocumentOpened;
impl ydp_core::Event for DocumentOpened {
type Params = DocumentOpenedParams;
const METHOD: &'static str = "Page.documentOpened";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DomContentEventFiredParams {
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for DomContentEventFiredParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DomContentEventFiredParams;
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 = "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(DomContentEventFiredParams {
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DomContentEventFired;
impl ydp_core::Event for DomContentEventFired {
type Params = DomContentEventFiredParams;
const METHOD: &'static str = "Page.domContentEventFired";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum DownloadProgressParamsState {
InProgress,
Completed,
Canceled,
Unknown(String),
}
impl DownloadProgressParamsState {
pub fn as_str(&self) -> &str {
match self {
Self::InProgress => "inProgress",
Self::Completed => "completed",
Self::Canceled => "canceled",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for DownloadProgressParamsState {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for DownloadProgressParamsState {
fn from(value: String) -> Self {
match value.as_str() {
"inProgress" => DownloadProgressParamsState::InProgress,
"completed" => DownloadProgressParamsState::Completed,
"canceled" => DownloadProgressParamsState::Canceled,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for DownloadProgressParamsState {
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 DownloadProgressParamsState {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DownloadProgressParamsState;
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 {
"inProgress" => DownloadProgressParamsState::InProgress,
"completed" => DownloadProgressParamsState::Completed,
"canceled" => DownloadProgressParamsState::Canceled,
_ => DownloadProgressParamsState::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(DownloadProgressParamsState::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DownloadProgressParams {
#[serde(rename = "guid")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub guid: String,
#[serde(rename = "totalBytes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub total_bytes: ydp_core::FiniteF64,
#[serde(rename = "receivedBytes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub received_bytes: ydp_core::FiniteF64,
#[serde(rename = "state")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub state: DownloadProgressParamsState,
}
impl<'de> serde::Deserialize<'de> for DownloadProgressParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DownloadProgressParams;
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 = "guid")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub guid: String,
#[serde(rename = "totalBytes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub total_bytes: ydp_core::FiniteF64,
#[serde(rename = "receivedBytes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub received_bytes: ydp_core::FiniteF64,
#[serde(rename = "state")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub state: DownloadProgressParamsState,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DownloadProgressParams {
guid: fields.guid,
total_bytes: fields.total_bytes,
received_bytes: fields.received_bytes,
state: fields.state,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DownloadProgress;
impl ydp_core::Event for DownloadProgress {
type Params = DownloadProgressParams;
const METHOD: &'static str = "Page.downloadProgress";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DownloadWillBeginParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "guid")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub guid: String,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "suggestedFilename")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub suggested_filename: String,
}
impl<'de> serde::Deserialize<'de> for DownloadWillBeginParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DownloadWillBeginParams;
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 = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "guid")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub guid: String,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "suggestedFilename")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub suggested_filename: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DownloadWillBeginParams {
frame_id: fields.frame_id,
guid: fields.guid,
url: fields.url,
suggested_filename: fields.suggested_filename,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DownloadWillBegin;
impl ydp_core::Event for DownloadWillBegin {
type Params = DownloadWillBeginParams;
const METHOD: &'static str = "Page.downloadWillBegin";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum FileChooserOpenedParamsMode {
SelectSingle,
SelectMultiple,
Unknown(String),
}
impl FileChooserOpenedParamsMode {
pub fn as_str(&self) -> &str {
match self {
Self::SelectSingle => "selectSingle",
Self::SelectMultiple => "selectMultiple",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for FileChooserOpenedParamsMode {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for FileChooserOpenedParamsMode {
fn from(value: String) -> Self {
match value.as_str() {
"selectSingle" => FileChooserOpenedParamsMode::SelectSingle,
"selectMultiple" => FileChooserOpenedParamsMode::SelectMultiple,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for FileChooserOpenedParamsMode {
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 FileChooserOpenedParamsMode {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FileChooserOpenedParamsMode;
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 {
"selectSingle" => FileChooserOpenedParamsMode::SelectSingle,
"selectMultiple" => FileChooserOpenedParamsMode::SelectMultiple,
_ => FileChooserOpenedParamsMode::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(FileChooserOpenedParamsMode::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct FileChooserOpenedParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "mode")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub mode: FileChooserOpenedParamsMode,
#[serde(rename = "backendNodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub backend_node_id: Option<crate::dom::types::BackendNodeId>,
}
impl<'de> serde::Deserialize<'de> for FileChooserOpenedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FileChooserOpenedParams;
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 = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "mode")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub mode: FileChooserOpenedParamsMode,
#[serde(rename = "backendNodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub backend_node_id: Option<crate::dom::types::BackendNodeId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(FileChooserOpenedParams {
frame_id: fields.frame_id,
mode: fields.mode,
backend_node_id: fields.backend_node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct FileChooserOpened;
impl ydp_core::Event for FileChooserOpened {
type Params = FileChooserOpenedParams;
const METHOD: &'static str = "Page.fileChooserOpened";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct FrameAttachedParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "parentFrameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub parent_frame_id: crate::page::types::FrameId,
#[serde(rename = "stack")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub stack: Option<crate::runtime::types::StackTrace>,
}
impl<'de> serde::Deserialize<'de> for FrameAttachedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FrameAttachedParams;
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 = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "parentFrameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub parent_frame_id: crate::page::types::FrameId,
#[serde(rename = "stack")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub stack: Option<crate::runtime::types::StackTrace>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(FrameAttachedParams {
frame_id: fields.frame_id,
parent_frame_id: fields.parent_frame_id,
stack: fields.stack,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct FrameAttached;
impl ydp_core::Event for FrameAttached {
type Params = FrameAttachedParams;
const METHOD: &'static str = "Page.frameAttached";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct FrameClearedScheduledNavigationParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
impl<'de> serde::Deserialize<'de> for FrameClearedScheduledNavigationParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FrameClearedScheduledNavigationParams;
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 = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(FrameClearedScheduledNavigationParams {
frame_id: fields.frame_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct FrameClearedScheduledNavigation;
impl ydp_core::Event for FrameClearedScheduledNavigation {
type Params = FrameClearedScheduledNavigationParams;
const METHOD: &'static str = "Page.frameClearedScheduledNavigation";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum FrameDetachedParamsReason {
Remove,
Swap,
Unknown(String),
}
impl FrameDetachedParamsReason {
pub fn as_str(&self) -> &str {
match self {
Self::Remove => "remove",
Self::Swap => "swap",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for FrameDetachedParamsReason {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for FrameDetachedParamsReason {
fn from(value: String) -> Self {
match value.as_str() {
"remove" => FrameDetachedParamsReason::Remove,
"swap" => FrameDetachedParamsReason::Swap,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for FrameDetachedParamsReason {
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 FrameDetachedParamsReason {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FrameDetachedParamsReason;
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 {
"remove" => FrameDetachedParamsReason::Remove,
"swap" => FrameDetachedParamsReason::Swap,
_ => FrameDetachedParamsReason::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(FrameDetachedParamsReason::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct FrameDetachedParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "reason")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub reason: FrameDetachedParamsReason,
}
impl<'de> serde::Deserialize<'de> for FrameDetachedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FrameDetachedParams;
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 = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "reason")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub reason: FrameDetachedParamsReason,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(FrameDetachedParams {
frame_id: fields.frame_id,
reason: fields.reason,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct FrameDetached;
impl ydp_core::Event for FrameDetached {
type Params = FrameDetachedParams;
const METHOD: &'static str = "Page.frameDetached";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct FrameNavigatedParams {
#[serde(rename = "frame")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame: crate::page::types::Frame,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::page::types::NavigationType,
}
impl<'de> serde::Deserialize<'de> for FrameNavigatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FrameNavigatedParams;
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 = "frame")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame: crate::page::types::Frame,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::page::types::NavigationType,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(FrameNavigatedParams {
frame: fields.frame,
r#type: fields.r#type,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct FrameNavigated;
impl ydp_core::Event for FrameNavigated {
type Params = FrameNavigatedParams;
const METHOD: &'static str = "Page.frameNavigated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct FrameRequestedNavigationParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "reason")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub reason: crate::page::types::ClientNavigationReason,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "disposition")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub disposition: crate::page::types::ClientNavigationDisposition,
}
impl<'de> serde::Deserialize<'de> for FrameRequestedNavigationParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FrameRequestedNavigationParams;
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 = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "reason")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub reason: crate::page::types::ClientNavigationReason,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "disposition")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub disposition: crate::page::types::ClientNavigationDisposition,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(FrameRequestedNavigationParams {
frame_id: fields.frame_id,
reason: fields.reason,
url: fields.url,
disposition: fields.disposition,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct FrameRequestedNavigation;
impl ydp_core::Event for FrameRequestedNavigation {
type Params = FrameRequestedNavigationParams;
const METHOD: &'static str = "Page.frameRequestedNavigation";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct FrameResizedParams {}
impl<'de> serde::Deserialize<'de> for FrameResizedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FrameResizedParams;
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(FrameResizedParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct FrameResized;
impl ydp_core::Event for FrameResized {
type Params = FrameResizedParams;
const METHOD: &'static str = "Page.frameResized";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct FrameScheduledNavigationParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "delay")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub delay: ydp_core::FiniteF64,
#[serde(rename = "reason")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub reason: crate::page::types::ClientNavigationReason,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
}
impl<'de> serde::Deserialize<'de> for FrameScheduledNavigationParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FrameScheduledNavigationParams;
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 = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "delay")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub delay: ydp_core::FiniteF64,
#[serde(rename = "reason")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub reason: crate::page::types::ClientNavigationReason,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(FrameScheduledNavigationParams {
frame_id: fields.frame_id,
delay: fields.delay,
reason: fields.reason,
url: fields.url,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct FrameScheduledNavigation;
impl ydp_core::Event for FrameScheduledNavigation {
type Params = FrameScheduledNavigationParams;
const METHOD: &'static str = "Page.frameScheduledNavigation";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct FrameStartedLoadingParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
impl<'de> serde::Deserialize<'de> for FrameStartedLoadingParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FrameStartedLoadingParams;
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 = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(FrameStartedLoadingParams {
frame_id: fields.frame_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct FrameStartedLoading;
impl ydp_core::Event for FrameStartedLoading {
type Params = FrameStartedLoadingParams;
const METHOD: &'static str = "Page.frameStartedLoading";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum FrameStartedNavigatingParamsNavigationType {
Reload,
ReloadBypassingCache,
Restore,
RestoreWithPost,
HistorySameDocument,
HistoryDifferentDocument,
SameDocument,
DifferentDocument,
Unknown(String),
}
impl FrameStartedNavigatingParamsNavigationType {
pub fn as_str(&self) -> &str {
match self {
Self::Reload => "reload",
Self::ReloadBypassingCache => "reloadBypassingCache",
Self::Restore => "restore",
Self::RestoreWithPost => "restoreWithPost",
Self::HistorySameDocument => "historySameDocument",
Self::HistoryDifferentDocument => "historyDifferentDocument",
Self::SameDocument => "sameDocument",
Self::DifferentDocument => "differentDocument",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for FrameStartedNavigatingParamsNavigationType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for FrameStartedNavigatingParamsNavigationType {
fn from(value: String) -> Self {
match value.as_str() {
"reload" => FrameStartedNavigatingParamsNavigationType::Reload,
"reloadBypassingCache" => {
FrameStartedNavigatingParamsNavigationType::ReloadBypassingCache
}
"restore" => FrameStartedNavigatingParamsNavigationType::Restore,
"restoreWithPost" => FrameStartedNavigatingParamsNavigationType::RestoreWithPost,
"historySameDocument" => {
FrameStartedNavigatingParamsNavigationType::HistorySameDocument
}
"historyDifferentDocument" => {
FrameStartedNavigatingParamsNavigationType::HistoryDifferentDocument
}
"sameDocument" => FrameStartedNavigatingParamsNavigationType::SameDocument,
"differentDocument" => FrameStartedNavigatingParamsNavigationType::DifferentDocument,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for FrameStartedNavigatingParamsNavigationType {
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 FrameStartedNavigatingParamsNavigationType {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FrameStartedNavigatingParamsNavigationType;
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 {
"reload" => FrameStartedNavigatingParamsNavigationType::Reload,
"reloadBypassingCache" => {
FrameStartedNavigatingParamsNavigationType::ReloadBypassingCache
}
"restore" => FrameStartedNavigatingParamsNavigationType::Restore,
"restoreWithPost" => {
FrameStartedNavigatingParamsNavigationType::RestoreWithPost
}
"historySameDocument" => {
FrameStartedNavigatingParamsNavigationType::HistorySameDocument
}
"historyDifferentDocument" => {
FrameStartedNavigatingParamsNavigationType::HistoryDifferentDocument
}
"sameDocument" => FrameStartedNavigatingParamsNavigationType::SameDocument,
"differentDocument" => {
FrameStartedNavigatingParamsNavigationType::DifferentDocument
}
_ => FrameStartedNavigatingParamsNavigationType::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(FrameStartedNavigatingParamsNavigationType::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct FrameStartedNavigatingParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "loaderId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub loader_id: crate::network::types::LoaderId,
#[serde(rename = "navigationType")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub navigation_type: FrameStartedNavigatingParamsNavigationType,
}
impl<'de> serde::Deserialize<'de> for FrameStartedNavigatingParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FrameStartedNavigatingParams;
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 = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "loaderId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub loader_id: crate::network::types::LoaderId,
#[serde(rename = "navigationType")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub navigation_type: FrameStartedNavigatingParamsNavigationType,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(FrameStartedNavigatingParams {
frame_id: fields.frame_id,
url: fields.url,
loader_id: fields.loader_id,
navigation_type: fields.navigation_type,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct FrameStartedNavigating;
impl ydp_core::Event for FrameStartedNavigating {
type Params = FrameStartedNavigatingParams;
const METHOD: &'static str = "Page.frameStartedNavigating";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct FrameStoppedLoadingParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
impl<'de> serde::Deserialize<'de> for FrameStoppedLoadingParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FrameStoppedLoadingParams;
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 = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(FrameStoppedLoadingParams {
frame_id: fields.frame_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct FrameStoppedLoading;
impl ydp_core::Event for FrameStoppedLoading {
type Params = FrameStoppedLoadingParams;
const METHOD: &'static str = "Page.frameStoppedLoading";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct FrameSubtreeWillBeDetachedParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
impl<'de> serde::Deserialize<'de> for FrameSubtreeWillBeDetachedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FrameSubtreeWillBeDetachedParams;
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 = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(FrameSubtreeWillBeDetachedParams {
frame_id: fields.frame_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct FrameSubtreeWillBeDetached;
impl ydp_core::Event for FrameSubtreeWillBeDetached {
type Params = FrameSubtreeWillBeDetachedParams;
const METHOD: &'static str = "Page.frameSubtreeWillBeDetached";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct InterstitialHiddenParams {}
impl<'de> serde::Deserialize<'de> for InterstitialHiddenParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = InterstitialHiddenParams;
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(InterstitialHiddenParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct InterstitialHidden;
impl ydp_core::Event for InterstitialHidden {
type Params = InterstitialHiddenParams;
const METHOD: &'static str = "Page.interstitialHidden";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct InterstitialShownParams {}
impl<'de> serde::Deserialize<'de> for InterstitialShownParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = InterstitialShownParams;
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(InterstitialShownParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct InterstitialShown;
impl ydp_core::Event for InterstitialShown {
type Params = InterstitialShownParams;
const METHOD: &'static str = "Page.interstitialShown";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct JavascriptDialogClosedParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "result")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub result: bool,
#[serde(rename = "userInput")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub user_input: String,
}
impl<'de> serde::Deserialize<'de> for JavascriptDialogClosedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = JavascriptDialogClosedParams;
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 = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "result")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub result: bool,
#[serde(rename = "userInput")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub user_input: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(JavascriptDialogClosedParams {
frame_id: fields.frame_id,
result: fields.result,
user_input: fields.user_input,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct JavascriptDialogClosed;
impl ydp_core::Event for JavascriptDialogClosed {
type Params = JavascriptDialogClosedParams;
const METHOD: &'static str = "Page.javascriptDialogClosed";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct JavascriptDialogOpeningParams {
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "message")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub message: String,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::page::types::DialogType,
#[serde(rename = "hasBrowserHandler")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub has_browser_handler: bool,
#[serde(rename = "defaultPrompt")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub default_prompt: Option<String>,
}
impl<'de> serde::Deserialize<'de> for JavascriptDialogOpeningParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = JavascriptDialogOpeningParams;
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 = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "message")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub message: String,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::page::types::DialogType,
#[serde(rename = "hasBrowserHandler")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub has_browser_handler: bool,
#[serde(rename = "defaultPrompt")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub default_prompt: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(JavascriptDialogOpeningParams {
url: fields.url,
frame_id: fields.frame_id,
message: fields.message,
r#type: fields.r#type,
has_browser_handler: fields.has_browser_handler,
default_prompt: fields.default_prompt,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct JavascriptDialogOpening;
impl ydp_core::Event for JavascriptDialogOpening {
type Params = JavascriptDialogOpeningParams;
const METHOD: &'static str = "Page.javascriptDialogOpening";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct LifecycleEventParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "loaderId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub loader_id: crate::network::types::LoaderId,
#[serde(rename = "name")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub name: String,
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for LifecycleEventParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = LifecycleEventParams;
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 = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "loaderId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub loader_id: crate::network::types::LoaderId,
#[serde(rename = "name")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub name: 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(LifecycleEventParams {
frame_id: fields.frame_id,
loader_id: fields.loader_id,
name: fields.name,
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct LifecycleEvent;
impl ydp_core::Event for LifecycleEvent {
type Params = LifecycleEventParams;
const METHOD: &'static str = "Page.lifecycleEvent";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct LoadEventFiredParams {
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::network::types::MonotonicTime,
}
impl<'de> serde::Deserialize<'de> for LoadEventFiredParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = LoadEventFiredParams;
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 = "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(LoadEventFiredParams {
timestamp: fields.timestamp,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct LoadEventFired;
impl ydp_core::Event for LoadEventFired {
type Params = LoadEventFiredParams;
const METHOD: &'static str = "Page.loadEventFired";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum NavigatedWithinDocumentParamsNavigationType {
Fragment,
HistoryApi,
Other,
Unknown(String),
}
impl NavigatedWithinDocumentParamsNavigationType {
pub fn as_str(&self) -> &str {
match self {
Self::Fragment => "fragment",
Self::HistoryApi => "historyApi",
Self::Other => "other",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for NavigatedWithinDocumentParamsNavigationType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for NavigatedWithinDocumentParamsNavigationType {
fn from(value: String) -> Self {
match value.as_str() {
"fragment" => NavigatedWithinDocumentParamsNavigationType::Fragment,
"historyApi" => NavigatedWithinDocumentParamsNavigationType::HistoryApi,
"other" => NavigatedWithinDocumentParamsNavigationType::Other,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for NavigatedWithinDocumentParamsNavigationType {
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 NavigatedWithinDocumentParamsNavigationType {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = NavigatedWithinDocumentParamsNavigationType;
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 {
"fragment" => NavigatedWithinDocumentParamsNavigationType::Fragment,
"historyApi" => NavigatedWithinDocumentParamsNavigationType::HistoryApi,
"other" => NavigatedWithinDocumentParamsNavigationType::Other,
_ => NavigatedWithinDocumentParamsNavigationType::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(NavigatedWithinDocumentParamsNavigationType::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct NavigatedWithinDocumentParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "navigationType")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub navigation_type: NavigatedWithinDocumentParamsNavigationType,
}
impl<'de> serde::Deserialize<'de> for NavigatedWithinDocumentParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = NavigatedWithinDocumentParams;
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 = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "navigationType")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub navigation_type: NavigatedWithinDocumentParamsNavigationType,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(NavigatedWithinDocumentParams {
frame_id: fields.frame_id,
url: fields.url,
navigation_type: fields.navigation_type,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct NavigatedWithinDocument;
impl ydp_core::Event for NavigatedWithinDocument {
type Params = NavigatedWithinDocumentParams;
const METHOD: &'static str = "Page.navigatedWithinDocument";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ScreencastFrameParams {
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
#[serde(rename = "metadata")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub metadata: crate::page::types::ScreencastFrameMetadata,
#[serde(rename = "sessionId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub session_id: i64,
}
impl<'de> serde::Deserialize<'de> for ScreencastFrameParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ScreencastFrameParams;
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 = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
#[serde(rename = "metadata")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub metadata: crate::page::types::ScreencastFrameMetadata,
#[serde(rename = "sessionId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub session_id: i64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ScreencastFrameParams {
data: fields.data,
metadata: fields.metadata,
session_id: fields.session_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ScreencastFrame;
impl ydp_core::Event for ScreencastFrame {
type Params = ScreencastFrameParams;
const METHOD: &'static str = "Page.screencastFrame";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ScreencastVisibilityChangedParams {
#[serde(rename = "visible")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub visible: bool,
}
impl<'de> serde::Deserialize<'de> for ScreencastVisibilityChangedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ScreencastVisibilityChangedParams;
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 = "visible")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub visible: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ScreencastVisibilityChangedParams {
visible: fields.visible,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ScreencastVisibilityChanged;
impl ydp_core::Event for ScreencastVisibilityChanged {
type Params = ScreencastVisibilityChangedParams;
const METHOD: &'static str = "Page.screencastVisibilityChanged";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct WindowOpenParams {
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "windowName")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub window_name: String,
#[serde(rename = "windowFeatures")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub window_features: Vec<String>,
#[serde(rename = "userGesture")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub user_gesture: bool,
}
impl<'de> serde::Deserialize<'de> for WindowOpenParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = WindowOpenParams;
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 = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "windowName")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub window_name: String,
#[serde(rename = "windowFeatures")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub window_features: Vec<String>,
#[serde(rename = "userGesture")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub user_gesture: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(WindowOpenParams {
url: fields.url,
window_name: fields.window_name,
window_features: fields.window_features,
user_gesture: fields.user_gesture,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct WindowOpen;
impl ydp_core::Event for WindowOpen {
type Params = WindowOpenParams;
const METHOD: &'static str = "Page.windowOpen";
}