#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct InspectModeCanceledParams {}
impl<'de> serde::Deserialize<'de> for InspectModeCanceledParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = InspectModeCanceledParams;
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(InspectModeCanceledParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct InspectModeCanceled;
impl ydp_core::Event for InspectModeCanceled {
type Params = InspectModeCanceledParams;
const METHOD: &'static str = "Overlay.inspectModeCanceled";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct InspectNodeRequestedParams {
#[serde(rename = "backendNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub backend_node_id: crate::dom::types::BackendNodeId,
}
impl<'de> serde::Deserialize<'de> for InspectNodeRequestedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = InspectNodeRequestedParams;
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 = "backendNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub backend_node_id: crate::dom::types::BackendNodeId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(InspectNodeRequestedParams {
backend_node_id: fields.backend_node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct InspectNodeRequested;
impl ydp_core::Event for InspectNodeRequested {
type Params = InspectNodeRequestedParams;
const METHOD: &'static str = "Overlay.inspectNodeRequested";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct InspectPanelShowRequestedParams {
#[serde(rename = "backendNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub backend_node_id: crate::dom::types::BackendNodeId,
}
impl<'de> serde::Deserialize<'de> for InspectPanelShowRequestedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = InspectPanelShowRequestedParams;
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 = "backendNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub backend_node_id: crate::dom::types::BackendNodeId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(InspectPanelShowRequestedParams {
backend_node_id: fields.backend_node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct InspectPanelShowRequested;
impl ydp_core::Event for InspectPanelShowRequested {
type Params = InspectPanelShowRequestedParams;
const METHOD: &'static str = "Overlay.inspectPanelShowRequested";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct InspectedElementWindowRestoredParams {
#[serde(rename = "backendNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub backend_node_id: crate::dom::types::BackendNodeId,
}
impl<'de> serde::Deserialize<'de> for InspectedElementWindowRestoredParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = InspectedElementWindowRestoredParams;
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 = "backendNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub backend_node_id: crate::dom::types::BackendNodeId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(InspectedElementWindowRestoredParams {
backend_node_id: fields.backend_node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct InspectedElementWindowRestored;
impl ydp_core::Event for InspectedElementWindowRestored {
type Params = InspectedElementWindowRestoredParams;
const METHOD: &'static str = "Overlay.inspectedElementWindowRestored";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct NodeHighlightRequestedParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for NodeHighlightRequestedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = NodeHighlightRequestedParams;
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 = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(NodeHighlightRequestedParams {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct NodeHighlightRequested;
impl ydp_core::Event for NodeHighlightRequested {
type Params = NodeHighlightRequestedParams;
const METHOD: &'static str = "Overlay.nodeHighlightRequested";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ScreenshotRequestedParams {
#[serde(rename = "viewport")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub viewport: crate::page::types::Viewport,
}
impl<'de> serde::Deserialize<'de> for ScreenshotRequestedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ScreenshotRequestedParams;
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 = "viewport")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub viewport: crate::page::types::Viewport,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ScreenshotRequestedParams {
viewport: fields.viewport,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ScreenshotRequested;
impl ydp_core::Event for ScreenshotRequested {
type Params = ScreenshotRequestedParams;
const METHOD: &'static str = "Overlay.screenshotRequested";
}