#[derive(Debug, Clone, serde::Serialize)]
pub struct AdRelatedStateUpdatedParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "adProvenance")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub ad_provenance: Option<crate::network::types::AdProvenance>,
}
impl<'de> serde::Deserialize<'de> for AdRelatedStateUpdatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AdRelatedStateUpdatedParams;
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,
#[serde(rename = "adProvenance")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub ad_provenance: Option<crate::network::types::AdProvenance>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AdRelatedStateUpdatedParams {
node_id: fields.node_id,
ad_provenance: fields.ad_provenance,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AdRelatedStateUpdated;
impl ydp_core::Event for AdRelatedStateUpdated {
type Params = AdRelatedStateUpdatedParams;
const METHOD: &'static str = "DOM.adRelatedStateUpdated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AdoptedStyleSheetsModifiedParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "adoptedStyleSheets")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub adopted_style_sheets: Vec<crate::dom::types::StyleSheetId>,
}
impl<'de> serde::Deserialize<'de> for AdoptedStyleSheetsModifiedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AdoptedStyleSheetsModifiedParams;
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,
#[serde(rename = "adoptedStyleSheets")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub adopted_style_sheets: Vec<crate::dom::types::StyleSheetId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AdoptedStyleSheetsModifiedParams {
node_id: fields.node_id,
adopted_style_sheets: fields.adopted_style_sheets,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AdoptedStyleSheetsModified;
impl ydp_core::Event for AdoptedStyleSheetsModified {
type Params = AdoptedStyleSheetsModifiedParams;
const METHOD: &'static str = "DOM.adoptedStyleSheetsModified";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AffectedByStartingStylesFlagUpdatedParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "affectedByStartingStyles")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub affected_by_starting_styles: bool,
}
impl<'de> serde::Deserialize<'de> for AffectedByStartingStylesFlagUpdatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AffectedByStartingStylesFlagUpdatedParams;
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,
#[serde(rename = "affectedByStartingStyles")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub affected_by_starting_styles: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AffectedByStartingStylesFlagUpdatedParams {
node_id: fields.node_id,
affected_by_starting_styles: fields.affected_by_starting_styles,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AffectedByStartingStylesFlagUpdated;
impl ydp_core::Event for AffectedByStartingStylesFlagUpdated {
type Params = AffectedByStartingStylesFlagUpdatedParams;
const METHOD: &'static str = "DOM.affectedByStartingStylesFlagUpdated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AttributeModifiedParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "name")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub name: String,
#[serde(rename = "value")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub value: String,
}
impl<'de> serde::Deserialize<'de> for AttributeModifiedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AttributeModifiedParams;
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,
#[serde(rename = "name")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub name: String,
#[serde(rename = "value")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub value: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AttributeModifiedParams {
node_id: fields.node_id,
name: fields.name,
value: fields.value,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AttributeModified;
impl ydp_core::Event for AttributeModified {
type Params = AttributeModifiedParams;
const METHOD: &'static str = "DOM.attributeModified";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AttributeRemovedParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "name")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub name: String,
}
impl<'de> serde::Deserialize<'de> for AttributeRemovedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AttributeRemovedParams;
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,
#[serde(rename = "name")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub name: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AttributeRemovedParams {
node_id: fields.node_id,
name: fields.name,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AttributeRemoved;
impl ydp_core::Event for AttributeRemoved {
type Params = AttributeRemovedParams;
const METHOD: &'static str = "DOM.attributeRemoved";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct CharacterDataModifiedParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "characterData")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub character_data: String,
}
impl<'de> serde::Deserialize<'de> for CharacterDataModifiedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CharacterDataModifiedParams;
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,
#[serde(rename = "characterData")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub character_data: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CharacterDataModifiedParams {
node_id: fields.node_id,
character_data: fields.character_data,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct CharacterDataModified;
impl ydp_core::Event for CharacterDataModified {
type Params = CharacterDataModifiedParams;
const METHOD: &'static str = "DOM.characterDataModified";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ChildNodeCountUpdatedParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "childNodeCount")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub child_node_count: i64,
}
impl<'de> serde::Deserialize<'de> for ChildNodeCountUpdatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ChildNodeCountUpdatedParams;
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,
#[serde(rename = "childNodeCount")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub child_node_count: i64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ChildNodeCountUpdatedParams {
node_id: fields.node_id,
child_node_count: fields.child_node_count,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ChildNodeCountUpdated;
impl ydp_core::Event for ChildNodeCountUpdated {
type Params = ChildNodeCountUpdatedParams;
const METHOD: &'static str = "DOM.childNodeCountUpdated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ChildNodeInsertedParams {
#[serde(rename = "parentNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub parent_node_id: crate::dom::types::NodeId,
#[serde(rename = "previousNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub previous_node_id: crate::dom::types::NodeId,
#[serde(rename = "node")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node: crate::dom::types::Node,
}
impl<'de> serde::Deserialize<'de> for ChildNodeInsertedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ChildNodeInsertedParams;
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 = "parentNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub parent_node_id: crate::dom::types::NodeId,
#[serde(rename = "previousNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub previous_node_id: crate::dom::types::NodeId,
#[serde(rename = "node")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node: crate::dom::types::Node,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ChildNodeInsertedParams {
parent_node_id: fields.parent_node_id,
previous_node_id: fields.previous_node_id,
node: fields.node,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ChildNodeInserted;
impl ydp_core::Event for ChildNodeInserted {
type Params = ChildNodeInsertedParams;
const METHOD: &'static str = "DOM.childNodeInserted";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ChildNodeRemovedParams {
#[serde(rename = "parentNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub parent_node_id: crate::dom::types::NodeId,
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for ChildNodeRemovedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ChildNodeRemovedParams;
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 = "parentNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub parent_node_id: crate::dom::types::NodeId,
#[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(ChildNodeRemovedParams {
parent_node_id: fields.parent_node_id,
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ChildNodeRemoved;
impl ydp_core::Event for ChildNodeRemoved {
type Params = ChildNodeRemovedParams;
const METHOD: &'static str = "DOM.childNodeRemoved";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DistributedNodesUpdatedParams {
#[serde(rename = "insertionPointId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub insertion_point_id: crate::dom::types::NodeId,
#[serde(rename = "distributedNodes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub distributed_nodes: Vec<crate::dom::types::BackendNode>,
}
impl<'de> serde::Deserialize<'de> for DistributedNodesUpdatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DistributedNodesUpdatedParams;
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 = "insertionPointId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub insertion_point_id: crate::dom::types::NodeId,
#[serde(rename = "distributedNodes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub distributed_nodes: Vec<crate::dom::types::BackendNode>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DistributedNodesUpdatedParams {
insertion_point_id: fields.insertion_point_id,
distributed_nodes: fields.distributed_nodes,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DistributedNodesUpdated;
impl ydp_core::Event for DistributedNodesUpdated {
type Params = DistributedNodesUpdatedParams;
const METHOD: &'static str = "DOM.distributedNodesUpdated";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct DocumentUpdatedParams {}
impl<'de> serde::Deserialize<'de> for DocumentUpdatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DocumentUpdatedParams;
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(DocumentUpdatedParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DocumentUpdated;
impl ydp_core::Event for DocumentUpdated {
type Params = DocumentUpdatedParams;
const METHOD: &'static str = "DOM.documentUpdated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct InlineStyleInvalidatedParams {
#[serde(rename = "nodeIds")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_ids: Vec<crate::dom::types::NodeId>,
}
impl<'de> serde::Deserialize<'de> for InlineStyleInvalidatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = InlineStyleInvalidatedParams;
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 = "nodeIds")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_ids: Vec<crate::dom::types::NodeId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(InlineStyleInvalidatedParams {
node_ids: fields.node_ids,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct InlineStyleInvalidated;
impl ydp_core::Event for InlineStyleInvalidated {
type Params = InlineStyleInvalidatedParams;
const METHOD: &'static str = "DOM.inlineStyleInvalidated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct PseudoElementAddedParams {
#[serde(rename = "parentId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub parent_id: crate::dom::types::NodeId,
#[serde(rename = "pseudoElement")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub pseudo_element: crate::dom::types::Node,
}
impl<'de> serde::Deserialize<'de> for PseudoElementAddedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PseudoElementAddedParams;
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 = "parentId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub parent_id: crate::dom::types::NodeId,
#[serde(rename = "pseudoElement")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub pseudo_element: crate::dom::types::Node,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PseudoElementAddedParams {
parent_id: fields.parent_id,
pseudo_element: fields.pseudo_element,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct PseudoElementAdded;
impl ydp_core::Event for PseudoElementAdded {
type Params = PseudoElementAddedParams;
const METHOD: &'static str = "DOM.pseudoElementAdded";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct PseudoElementRemovedParams {
#[serde(rename = "parentId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub parent_id: crate::dom::types::NodeId,
#[serde(rename = "pseudoElementId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub pseudo_element_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for PseudoElementRemovedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PseudoElementRemovedParams;
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 = "parentId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub parent_id: crate::dom::types::NodeId,
#[serde(rename = "pseudoElementId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub pseudo_element_id: crate::dom::types::NodeId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PseudoElementRemovedParams {
parent_id: fields.parent_id,
pseudo_element_id: fields.pseudo_element_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct PseudoElementRemoved;
impl ydp_core::Event for PseudoElementRemoved {
type Params = PseudoElementRemovedParams;
const METHOD: &'static str = "DOM.pseudoElementRemoved";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ScrollableFlagUpdatedParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "isScrollable")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub is_scrollable: bool,
}
impl<'de> serde::Deserialize<'de> for ScrollableFlagUpdatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ScrollableFlagUpdatedParams;
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,
#[serde(rename = "isScrollable")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub is_scrollable: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ScrollableFlagUpdatedParams {
node_id: fields.node_id,
is_scrollable: fields.is_scrollable,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ScrollableFlagUpdated;
impl ydp_core::Event for ScrollableFlagUpdated {
type Params = ScrollableFlagUpdatedParams;
const METHOD: &'static str = "DOM.scrollableFlagUpdated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetChildNodesParams {
#[serde(rename = "parentId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub parent_id: crate::dom::types::NodeId,
#[serde(rename = "nodes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub nodes: Vec<crate::dom::types::Node>,
}
impl<'de> serde::Deserialize<'de> for SetChildNodesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetChildNodesParams;
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 = "parentId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub parent_id: crate::dom::types::NodeId,
#[serde(rename = "nodes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub nodes: Vec<crate::dom::types::Node>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetChildNodesParams {
parent_id: fields.parent_id,
nodes: fields.nodes,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetChildNodes;
impl ydp_core::Event for SetChildNodes {
type Params = SetChildNodesParams;
const METHOD: &'static str = "DOM.setChildNodes";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ShadowRootPoppedParams {
#[serde(rename = "hostId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub host_id: crate::dom::types::NodeId,
#[serde(rename = "rootId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub root_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for ShadowRootPoppedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ShadowRootPoppedParams;
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 = "hostId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub host_id: crate::dom::types::NodeId,
#[serde(rename = "rootId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub root_id: crate::dom::types::NodeId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ShadowRootPoppedParams {
host_id: fields.host_id,
root_id: fields.root_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ShadowRootPopped;
impl ydp_core::Event for ShadowRootPopped {
type Params = ShadowRootPoppedParams;
const METHOD: &'static str = "DOM.shadowRootPopped";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ShadowRootPushedParams {
#[serde(rename = "hostId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub host_id: crate::dom::types::NodeId,
#[serde(rename = "root")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub root: crate::dom::types::Node,
}
impl<'de> serde::Deserialize<'de> for ShadowRootPushedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ShadowRootPushedParams;
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 = "hostId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub host_id: crate::dom::types::NodeId,
#[serde(rename = "root")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub root: crate::dom::types::Node,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ShadowRootPushedParams {
host_id: fields.host_id,
root: fields.root,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ShadowRootPushed;
impl ydp_core::Event for ShadowRootPushed {
type Params = ShadowRootPushedParams;
const METHOD: &'static str = "DOM.shadowRootPushed";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct TopLayerElementsUpdatedParams {}
impl<'de> serde::Deserialize<'de> for TopLayerElementsUpdatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TopLayerElementsUpdatedParams;
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(TopLayerElementsUpdatedParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct TopLayerElementsUpdated;
impl ydp_core::Event for TopLayerElementsUpdated {
type Params = TopLayerElementsUpdatedParams;
const METHOD: &'static str = "DOM.topLayerElementsUpdated";
}