#[derive(Debug, Clone, serde::Serialize)]
pub struct CollectClassNamesFromSubtreeParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for CollectClassNamesFromSubtreeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CollectClassNamesFromSubtreeParams;
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(CollectClassNamesFromSubtreeParams {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct CollectClassNamesFromSubtree;
#[derive(Debug, Clone, serde::Serialize)]
pub struct CollectClassNamesFromSubtreeResponse {
#[serde(rename = "classNames")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub class_names: Vec<String>,
}
impl<'de> serde::Deserialize<'de> for CollectClassNamesFromSubtreeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CollectClassNamesFromSubtreeResponse;
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 = "classNames")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub class_names: Vec<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CollectClassNamesFromSubtreeResponse {
class_names: fields.class_names,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for CollectClassNamesFromSubtree {
type Params = CollectClassNamesFromSubtreeParams;
type Response = CollectClassNamesFromSubtreeResponse;
const METHOD: &'static str = "DOM.collectClassNamesFromSubtree";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct CopyToParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "targetNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub target_node_id: crate::dom::types::NodeId,
#[serde(rename = "insertBeforeNodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub insert_before_node_id: Option<crate::dom::types::NodeId>,
}
impl<'de> serde::Deserialize<'de> for CopyToParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CopyToParams;
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 = "targetNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub target_node_id: crate::dom::types::NodeId,
#[serde(rename = "insertBeforeNodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub insert_before_node_id: Option<crate::dom::types::NodeId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CopyToParams {
node_id: fields.node_id,
target_node_id: fields.target_node_id,
insert_before_node_id: fields.insert_before_node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct CopyTo;
#[derive(Debug, Clone, serde::Serialize)]
pub struct CopyToResponse {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for CopyToResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CopyToResponse;
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(CopyToResponse {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for CopyTo {
type Params = CopyToParams;
type Response = CopyToResponse;
const METHOD: &'static str = "DOM.copyTo";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct DescribeNodeParams {
#[serde(rename = "nodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_id: Option<crate::runtime::types::RemoteObjectId>,
#[serde(rename = "depth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub depth: Option<i64>,
#[serde(rename = "pierce")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub pierce: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for DescribeNodeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DescribeNodeParams;
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(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_id: Option<crate::runtime::types::RemoteObjectId>,
#[serde(rename = "depth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub depth: Option<i64>,
#[serde(rename = "pierce")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub pierce: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DescribeNodeParams {
node_id: fields.node_id,
backend_node_id: fields.backend_node_id,
object_id: fields.object_id,
depth: fields.depth,
pierce: fields.pierce,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DescribeNode;
#[derive(Debug, Clone, serde::Serialize)]
pub struct DescribeNodeResponse {
#[serde(rename = "node")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node: crate::dom::types::Node,
}
impl<'de> serde::Deserialize<'de> for DescribeNodeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DescribeNodeResponse;
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 = "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(DescribeNodeResponse { node: fields.node })
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for DescribeNode {
type Params = DescribeNodeParams;
type Response = DescribeNodeResponse;
const METHOD: &'static str = "DOM.describeNode";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct DisableParams {}
impl<'de> serde::Deserialize<'de> for DisableParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DisableParams;
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(DisableParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Disable;
#[derive(Debug, Clone, serde::Serialize)]
pub struct DisableResponse {}
impl<'de> serde::Deserialize<'de> for DisableResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DisableResponse;
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(DisableResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Disable {
type Params = DisableParams;
type Response = DisableResponse;
const METHOD: &'static str = "DOM.disable";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DiscardSearchResultsParams {
#[serde(rename = "searchId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub search_id: String,
}
impl<'de> serde::Deserialize<'de> for DiscardSearchResultsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DiscardSearchResultsParams;
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 = "searchId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub search_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DiscardSearchResultsParams {
search_id: fields.search_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DiscardSearchResults;
#[derive(Debug, Clone, serde::Serialize)]
pub struct DiscardSearchResultsResponse {}
impl<'de> serde::Deserialize<'de> for DiscardSearchResultsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DiscardSearchResultsResponse;
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(DiscardSearchResultsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for DiscardSearchResults {
type Params = DiscardSearchResultsParams;
type Response = DiscardSearchResultsResponse;
const METHOD: &'static str = "DOM.discardSearchResults";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum EnableParamsIncludeWhitespace {
None,
All,
Unknown(String),
}
impl EnableParamsIncludeWhitespace {
pub fn as_str(&self) -> &str {
match self {
Self::None => "none",
Self::All => "all",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for EnableParamsIncludeWhitespace {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for EnableParamsIncludeWhitespace {
fn from(value: String) -> Self {
match value.as_str() {
"none" => EnableParamsIncludeWhitespace::None,
"all" => EnableParamsIncludeWhitespace::All,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for EnableParamsIncludeWhitespace {
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 EnableParamsIncludeWhitespace {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = EnableParamsIncludeWhitespace;
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 {
"none" => EnableParamsIncludeWhitespace::None,
"all" => EnableParamsIncludeWhitespace::All,
_ => EnableParamsIncludeWhitespace::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(EnableParamsIncludeWhitespace::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct EnableParams {
#[serde(rename = "includeWhitespace")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_whitespace: Option<EnableParamsIncludeWhitespace>,
}
impl<'de> serde::Deserialize<'de> for EnableParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = EnableParams;
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 = "includeWhitespace")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_whitespace: Option<EnableParamsIncludeWhitespace>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(EnableParams {
include_whitespace: fields.include_whitespace,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Enable;
#[derive(Debug, Clone, serde::Serialize)]
pub struct EnableResponse {}
impl<'de> serde::Deserialize<'de> for EnableResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = EnableResponse;
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(EnableResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Enable {
type Params = EnableParams;
type Response = EnableResponse;
const METHOD: &'static str = "DOM.enable";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct FocusParams {
#[serde(rename = "nodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_id: Option<crate::runtime::types::RemoteObjectId>,
}
impl<'de> serde::Deserialize<'de> for FocusParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FocusParams;
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(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_id: Option<crate::runtime::types::RemoteObjectId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(FocusParams {
node_id: fields.node_id,
backend_node_id: fields.backend_node_id,
object_id: fields.object_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Focus;
#[derive(Debug, Clone, serde::Serialize)]
pub struct FocusResponse {}
impl<'de> serde::Deserialize<'de> for FocusResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = FocusResponse;
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(FocusResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Focus {
type Params = FocusParams;
type Response = FocusResponse;
const METHOD: &'static str = "DOM.focus";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ForceShowInterestParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "enable")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enable: bool,
}
impl<'de> serde::Deserialize<'de> for ForceShowInterestParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ForceShowInterestParams;
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 = "enable")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enable: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ForceShowInterestParams {
node_id: fields.node_id,
enable: fields.enable,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ForceShowInterest;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ForceShowInterestResponse {}
impl<'de> serde::Deserialize<'de> for ForceShowInterestResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ForceShowInterestResponse;
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(ForceShowInterestResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ForceShowInterest {
type Params = ForceShowInterestParams;
type Response = ForceShowInterestResponse;
const METHOD: &'static str = "DOM.forceShowInterest";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ForceShowPopoverParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "enable")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enable: bool,
#[serde(rename = "invokerNodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub invoker_node_id: Option<crate::dom::types::BackendNodeId>,
}
impl<'de> serde::Deserialize<'de> for ForceShowPopoverParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ForceShowPopoverParams;
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 = "enable")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enable: bool,
#[serde(rename = "invokerNodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub invoker_node_id: Option<crate::dom::types::BackendNodeId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ForceShowPopoverParams {
node_id: fields.node_id,
enable: fields.enable,
invoker_node_id: fields.invoker_node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ForceShowPopover;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ForceShowPopoverResponse {
#[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 ForceShowPopoverResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ForceShowPopoverResponse;
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(ForceShowPopoverResponse {
node_ids: fields.node_ids,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ForceShowPopover {
type Params = ForceShowPopoverParams;
type Response = ForceShowPopoverResponse;
const METHOD: &'static str = "DOM.forceShowPopover";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetAnchorElementParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "anchorSpecifier")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub anchor_specifier: Option<String>,
}
impl<'de> serde::Deserialize<'de> for GetAnchorElementParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetAnchorElementParams;
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 = "anchorSpecifier")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub anchor_specifier: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetAnchorElementParams {
node_id: fields.node_id,
anchor_specifier: fields.anchor_specifier,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetAnchorElement;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetAnchorElementResponse {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for GetAnchorElementResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetAnchorElementResponse;
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(GetAnchorElementResponse {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetAnchorElement {
type Params = GetAnchorElementParams;
type Response = GetAnchorElementResponse;
const METHOD: &'static str = "DOM.getAnchorElement";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetAttributesParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for GetAttributesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetAttributesParams;
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(GetAttributesParams {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetAttributes;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetAttributesResponse {
#[serde(rename = "attributes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub attributes: Vec<String>,
}
impl<'de> serde::Deserialize<'de> for GetAttributesResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetAttributesResponse;
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 = "attributes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub attributes: Vec<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetAttributesResponse {
attributes: fields.attributes,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetAttributes {
type Params = GetAttributesParams;
type Response = GetAttributesResponse;
const METHOD: &'static str = "DOM.getAttributes";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetBoxModelParams {
#[serde(rename = "nodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_id: Option<crate::runtime::types::RemoteObjectId>,
}
impl<'de> serde::Deserialize<'de> for GetBoxModelParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetBoxModelParams;
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(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_id: Option<crate::runtime::types::RemoteObjectId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetBoxModelParams {
node_id: fields.node_id,
backend_node_id: fields.backend_node_id,
object_id: fields.object_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetBoxModel;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetBoxModelResponse {
#[serde(rename = "model")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub model: crate::dom::types::BoxModel,
}
impl<'de> serde::Deserialize<'de> for GetBoxModelResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetBoxModelResponse;
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 = "model")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub model: crate::dom::types::BoxModel,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetBoxModelResponse {
model: fields.model,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetBoxModel {
type Params = GetBoxModelParams;
type Response = GetBoxModelResponse;
const METHOD: &'static str = "DOM.getBoxModel";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetContainerForNodeParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "containerName")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub container_name: Option<String>,
#[serde(rename = "physicalAxes")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub physical_axes: Option<crate::dom::types::PhysicalAxes>,
#[serde(rename = "logicalAxes")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub logical_axes: Option<crate::dom::types::LogicalAxes>,
#[serde(rename = "queriesScrollState")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub queries_scroll_state: Option<bool>,
#[serde(rename = "queriesAnchored")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub queries_anchored: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for GetContainerForNodeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetContainerForNodeParams;
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 = "containerName")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub container_name: Option<String>,
#[serde(rename = "physicalAxes")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub physical_axes: Option<crate::dom::types::PhysicalAxes>,
#[serde(rename = "logicalAxes")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub logical_axes: Option<crate::dom::types::LogicalAxes>,
#[serde(rename = "queriesScrollState")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub queries_scroll_state: Option<bool>,
#[serde(rename = "queriesAnchored")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub queries_anchored: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetContainerForNodeParams {
node_id: fields.node_id,
container_name: fields.container_name,
physical_axes: fields.physical_axes,
logical_axes: fields.logical_axes,
queries_scroll_state: fields.queries_scroll_state,
queries_anchored: fields.queries_anchored,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetContainerForNode;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetContainerForNodeResponse {
#[serde(rename = "nodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
}
impl<'de> serde::Deserialize<'de> for GetContainerForNodeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetContainerForNodeResponse;
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(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetContainerForNodeResponse {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetContainerForNode {
type Params = GetContainerForNodeParams;
type Response = GetContainerForNodeResponse;
const METHOD: &'static str = "DOM.getContainerForNode";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetContentQuadsParams {
#[serde(rename = "nodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_id: Option<crate::runtime::types::RemoteObjectId>,
}
impl<'de> serde::Deserialize<'de> for GetContentQuadsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetContentQuadsParams;
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(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_id: Option<crate::runtime::types::RemoteObjectId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetContentQuadsParams {
node_id: fields.node_id,
backend_node_id: fields.backend_node_id,
object_id: fields.object_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetContentQuads;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetContentQuadsResponse {
#[serde(rename = "quads")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub quads: Vec<crate::dom::types::Quad>,
}
impl<'de> serde::Deserialize<'de> for GetContentQuadsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetContentQuadsResponse;
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 = "quads")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub quads: Vec<crate::dom::types::Quad>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetContentQuadsResponse {
quads: fields.quads,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetContentQuads {
type Params = GetContentQuadsParams;
type Response = GetContentQuadsResponse;
const METHOD: &'static str = "DOM.getContentQuads";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetDetachedDomNodesParams {}
impl<'de> serde::Deserialize<'de> for GetDetachedDomNodesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetDetachedDomNodesParams;
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(GetDetachedDomNodesParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetDetachedDomNodes;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetDetachedDomNodesResponse {
#[serde(rename = "detachedNodes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub detached_nodes: Vec<crate::dom::types::DetachedElementInfo>,
}
impl<'de> serde::Deserialize<'de> for GetDetachedDomNodesResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetDetachedDomNodesResponse;
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 = "detachedNodes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub detached_nodes: Vec<crate::dom::types::DetachedElementInfo>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetDetachedDomNodesResponse {
detached_nodes: fields.detached_nodes,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetDetachedDomNodes {
type Params = GetDetachedDomNodesParams;
type Response = GetDetachedDomNodesResponse;
const METHOD: &'static str = "DOM.getDetachedDomNodes";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetDocumentParams {
#[serde(rename = "depth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub depth: Option<i64>,
#[serde(rename = "pierce")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub pierce: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for GetDocumentParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetDocumentParams;
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 = "depth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub depth: Option<i64>,
#[serde(rename = "pierce")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub pierce: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetDocumentParams {
depth: fields.depth,
pierce: fields.pierce,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetDocument;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetDocumentResponse {
#[serde(rename = "root")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub root: crate::dom::types::Node,
}
impl<'de> serde::Deserialize<'de> for GetDocumentResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetDocumentResponse;
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 = "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(GetDocumentResponse { root: fields.root })
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetDocument {
type Params = GetDocumentParams;
type Response = GetDocumentResponse;
const METHOD: &'static str = "DOM.getDocument";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum GetElementByRelationParamsRelation {
PopoverTarget,
InterestTarget,
CommandFor,
Unknown(String),
}
impl GetElementByRelationParamsRelation {
pub fn as_str(&self) -> &str {
match self {
Self::PopoverTarget => "PopoverTarget",
Self::InterestTarget => "InterestTarget",
Self::CommandFor => "CommandFor",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for GetElementByRelationParamsRelation {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for GetElementByRelationParamsRelation {
fn from(value: String) -> Self {
match value.as_str() {
"PopoverTarget" => GetElementByRelationParamsRelation::PopoverTarget,
"InterestTarget" => GetElementByRelationParamsRelation::InterestTarget,
"CommandFor" => GetElementByRelationParamsRelation::CommandFor,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for GetElementByRelationParamsRelation {
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 GetElementByRelationParamsRelation {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetElementByRelationParamsRelation;
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 {
"PopoverTarget" => GetElementByRelationParamsRelation::PopoverTarget,
"InterestTarget" => GetElementByRelationParamsRelation::InterestTarget,
"CommandFor" => GetElementByRelationParamsRelation::CommandFor,
_ => GetElementByRelationParamsRelation::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(GetElementByRelationParamsRelation::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetElementByRelationParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "relation")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub relation: GetElementByRelationParamsRelation,
}
impl<'de> serde::Deserialize<'de> for GetElementByRelationParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetElementByRelationParams;
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 = "relation")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub relation: GetElementByRelationParamsRelation,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetElementByRelationParams {
node_id: fields.node_id,
relation: fields.relation,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetElementByRelation;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetElementByRelationResponse {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for GetElementByRelationResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetElementByRelationResponse;
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(GetElementByRelationResponse {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetElementByRelation {
type Params = GetElementByRelationParams;
type Response = GetElementByRelationResponse;
const METHOD: &'static str = "DOM.getElementByRelation";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetFileInfoParams {
#[serde(rename = "objectId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub object_id: crate::runtime::types::RemoteObjectId,
}
impl<'de> serde::Deserialize<'de> for GetFileInfoParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetFileInfoParams;
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 = "objectId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub object_id: crate::runtime::types::RemoteObjectId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetFileInfoParams {
object_id: fields.object_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetFileInfo;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetFileInfoResponse {
#[serde(rename = "path")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub path: String,
}
impl<'de> serde::Deserialize<'de> for GetFileInfoResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetFileInfoResponse;
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 = "path")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub path: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetFileInfoResponse { path: fields.path })
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetFileInfo {
type Params = GetFileInfoParams;
type Response = GetFileInfoResponse;
const METHOD: &'static str = "DOM.getFileInfo";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetFlattenedDocumentParams {
#[serde(rename = "depth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub depth: Option<i64>,
#[serde(rename = "pierce")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub pierce: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for GetFlattenedDocumentParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetFlattenedDocumentParams;
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 = "depth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub depth: Option<i64>,
#[serde(rename = "pierce")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub pierce: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetFlattenedDocumentParams {
depth: fields.depth,
pierce: fields.pierce,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetFlattenedDocument;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetFlattenedDocumentResponse {
#[serde(rename = "nodes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub nodes: Vec<crate::dom::types::Node>,
}
impl<'de> serde::Deserialize<'de> for GetFlattenedDocumentResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetFlattenedDocumentResponse;
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 = "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(GetFlattenedDocumentResponse {
nodes: fields.nodes,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetFlattenedDocument {
type Params = GetFlattenedDocumentParams;
type Response = GetFlattenedDocumentResponse;
const METHOD: &'static str = "DOM.getFlattenedDocument";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetFrameOwnerParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
impl<'de> serde::Deserialize<'de> for GetFrameOwnerParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetFrameOwnerParams;
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(GetFrameOwnerParams {
frame_id: fields.frame_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetFrameOwner;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetFrameOwnerResponse {
#[serde(rename = "backendNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub backend_node_id: crate::dom::types::BackendNodeId,
#[serde(rename = "nodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
}
impl<'de> serde::Deserialize<'de> for GetFrameOwnerResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetFrameOwnerResponse;
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,
#[serde(rename = "nodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetFrameOwnerResponse {
backend_node_id: fields.backend_node_id,
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetFrameOwner {
type Params = GetFrameOwnerParams;
type Response = GetFrameOwnerResponse;
const METHOD: &'static str = "DOM.getFrameOwner";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetNodeForLocationParams {
#[serde(rename = "x")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub x: i64,
#[serde(rename = "y")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub y: i64,
#[serde(rename = "includeUserAgentShadowDOM")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_user_agent_shadow_dom: Option<bool>,
#[serde(rename = "ignorePointerEventsNone")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub ignore_pointer_events_none: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for GetNodeForLocationParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetNodeForLocationParams;
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 = "x")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub x: i64,
#[serde(rename = "y")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub y: i64,
#[serde(rename = "includeUserAgentShadowDOM")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_user_agent_shadow_dom: Option<bool>,
#[serde(rename = "ignorePointerEventsNone")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub ignore_pointer_events_none: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetNodeForLocationParams {
x: fields.x,
y: fields.y,
include_user_agent_shadow_dom: fields.include_user_agent_shadow_dom,
ignore_pointer_events_none: fields.ignore_pointer_events_none,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetNodeForLocation;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetNodeForLocationResponse {
#[serde(rename = "backendNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub backend_node_id: crate::dom::types::BackendNodeId,
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "nodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
}
impl<'de> serde::Deserialize<'de> for GetNodeForLocationResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetNodeForLocationResponse;
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,
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "nodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetNodeForLocationResponse {
backend_node_id: fields.backend_node_id,
frame_id: fields.frame_id,
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetNodeForLocation {
type Params = GetNodeForLocationParams;
type Response = GetNodeForLocationResponse;
const METHOD: &'static str = "DOM.getNodeForLocation";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetNodeStackTracesParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for GetNodeStackTracesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetNodeStackTracesParams;
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(GetNodeStackTracesParams {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetNodeStackTraces;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetNodeStackTracesResponse {
#[serde(rename = "creation")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub creation: Option<crate::runtime::types::StackTrace>,
}
impl<'de> serde::Deserialize<'de> for GetNodeStackTracesResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetNodeStackTracesResponse;
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 = "creation")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub creation: Option<crate::runtime::types::StackTrace>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetNodeStackTracesResponse {
creation: fields.creation,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetNodeStackTraces {
type Params = GetNodeStackTracesParams;
type Response = GetNodeStackTracesResponse;
const METHOD: &'static str = "DOM.getNodeStackTraces";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetNodesForSubtreeByStyleParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "computedStyles")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub computed_styles: Vec<crate::dom::types::CssComputedStyleProperty>,
#[serde(rename = "pierce")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub pierce: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for GetNodesForSubtreeByStyleParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetNodesForSubtreeByStyleParams;
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 = "computedStyles")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub computed_styles: Vec<crate::dom::types::CssComputedStyleProperty>,
#[serde(rename = "pierce")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub pierce: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetNodesForSubtreeByStyleParams {
node_id: fields.node_id,
computed_styles: fields.computed_styles,
pierce: fields.pierce,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetNodesForSubtreeByStyle;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetNodesForSubtreeByStyleResponse {
#[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 GetNodesForSubtreeByStyleResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetNodesForSubtreeByStyleResponse;
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(GetNodesForSubtreeByStyleResponse {
node_ids: fields.node_ids,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetNodesForSubtreeByStyle {
type Params = GetNodesForSubtreeByStyleParams;
type Response = GetNodesForSubtreeByStyleResponse;
const METHOD: &'static str = "DOM.getNodesForSubtreeByStyle";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetOuterHtmlParams {
#[serde(rename = "nodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_id: Option<crate::runtime::types::RemoteObjectId>,
#[serde(rename = "includeShadowDOM")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_shadow_dom: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for GetOuterHtmlParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetOuterHtmlParams;
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(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_id: Option<crate::runtime::types::RemoteObjectId>,
#[serde(rename = "includeShadowDOM")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_shadow_dom: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetOuterHtmlParams {
node_id: fields.node_id,
backend_node_id: fields.backend_node_id,
object_id: fields.object_id,
include_shadow_dom: fields.include_shadow_dom,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetOuterHtml;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetOuterHtmlResponse {
#[serde(rename = "outerHTML")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub outer_html: String,
}
impl<'de> serde::Deserialize<'de> for GetOuterHtmlResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetOuterHtmlResponse;
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 = "outerHTML")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub outer_html: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetOuterHtmlResponse {
outer_html: fields.outer_html,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetOuterHtml {
type Params = GetOuterHtmlParams;
type Response = GetOuterHtmlResponse;
const METHOD: &'static str = "DOM.getOuterHTML";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetQueryingDescendantsForContainerParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for GetQueryingDescendantsForContainerParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetQueryingDescendantsForContainerParams;
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(GetQueryingDescendantsForContainerParams {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetQueryingDescendantsForContainer;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetQueryingDescendantsForContainerResponse {
#[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 GetQueryingDescendantsForContainerResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetQueryingDescendantsForContainerResponse;
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(GetQueryingDescendantsForContainerResponse {
node_ids: fields.node_ids,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetQueryingDescendantsForContainer {
type Params = GetQueryingDescendantsForContainerParams;
type Response = GetQueryingDescendantsForContainerResponse;
const METHOD: &'static str = "DOM.getQueryingDescendantsForContainer";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetRelayoutBoundaryParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for GetRelayoutBoundaryParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetRelayoutBoundaryParams;
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(GetRelayoutBoundaryParams {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetRelayoutBoundary;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetRelayoutBoundaryResponse {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for GetRelayoutBoundaryResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetRelayoutBoundaryResponse;
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(GetRelayoutBoundaryResponse {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetRelayoutBoundary {
type Params = GetRelayoutBoundaryParams;
type Response = GetRelayoutBoundaryResponse;
const METHOD: &'static str = "DOM.getRelayoutBoundary";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetSearchResultsParams {
#[serde(rename = "searchId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub search_id: String,
#[serde(rename = "fromIndex")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub from_index: i64,
#[serde(rename = "toIndex")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub to_index: i64,
}
impl<'de> serde::Deserialize<'de> for GetSearchResultsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetSearchResultsParams;
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 = "searchId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub search_id: String,
#[serde(rename = "fromIndex")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub from_index: i64,
#[serde(rename = "toIndex")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub to_index: i64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetSearchResultsParams {
search_id: fields.search_id,
from_index: fields.from_index,
to_index: fields.to_index,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetSearchResults;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetSearchResultsResponse {
#[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 GetSearchResultsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetSearchResultsResponse;
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(GetSearchResultsResponse {
node_ids: fields.node_ids,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetSearchResults {
type Params = GetSearchResultsParams;
type Response = GetSearchResultsResponse;
const METHOD: &'static str = "DOM.getSearchResults";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetTopLayerElementsParams {}
impl<'de> serde::Deserialize<'de> for GetTopLayerElementsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetTopLayerElementsParams;
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(GetTopLayerElementsParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetTopLayerElements;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetTopLayerElementsResponse {
#[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 GetTopLayerElementsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetTopLayerElementsResponse;
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(GetTopLayerElementsResponse {
node_ids: fields.node_ids,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetTopLayerElements {
type Params = GetTopLayerElementsParams;
type Response = GetTopLayerElementsResponse;
const METHOD: &'static str = "DOM.getTopLayerElements";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct HideHighlightParams {}
impl<'de> serde::Deserialize<'de> for HideHighlightParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = HideHighlightParams;
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(HideHighlightParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct HideHighlight;
#[derive(Debug, Clone, serde::Serialize)]
pub struct HideHighlightResponse {}
impl<'de> serde::Deserialize<'de> for HideHighlightResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = HideHighlightResponse;
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(HideHighlightResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for HideHighlight {
type Params = HideHighlightParams;
type Response = HideHighlightResponse;
const METHOD: &'static str = "DOM.hideHighlight";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct HighlightNodeParams {}
impl<'de> serde::Deserialize<'de> for HighlightNodeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = HighlightNodeParams;
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(HighlightNodeParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct HighlightNode;
#[derive(Debug, Clone, serde::Serialize)]
pub struct HighlightNodeResponse {}
impl<'de> serde::Deserialize<'de> for HighlightNodeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = HighlightNodeResponse;
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(HighlightNodeResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for HighlightNode {
type Params = HighlightNodeParams;
type Response = HighlightNodeResponse;
const METHOD: &'static str = "DOM.highlightNode";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct HighlightRectParams {}
impl<'de> serde::Deserialize<'de> for HighlightRectParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = HighlightRectParams;
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(HighlightRectParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct HighlightRect;
#[derive(Debug, Clone, serde::Serialize)]
pub struct HighlightRectResponse {}
impl<'de> serde::Deserialize<'de> for HighlightRectResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = HighlightRectResponse;
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(HighlightRectResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for HighlightRect {
type Params = HighlightRectParams;
type Response = HighlightRectResponse;
const METHOD: &'static str = "DOM.highlightRect";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct MarkUndoableStateParams {}
impl<'de> serde::Deserialize<'de> for MarkUndoableStateParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = MarkUndoableStateParams;
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(MarkUndoableStateParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct MarkUndoableState;
#[derive(Debug, Clone, serde::Serialize)]
pub struct MarkUndoableStateResponse {}
impl<'de> serde::Deserialize<'de> for MarkUndoableStateResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = MarkUndoableStateResponse;
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(MarkUndoableStateResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for MarkUndoableState {
type Params = MarkUndoableStateParams;
type Response = MarkUndoableStateResponse;
const METHOD: &'static str = "DOM.markUndoableState";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct MoveToParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "targetNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub target_node_id: crate::dom::types::NodeId,
#[serde(rename = "insertBeforeNodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub insert_before_node_id: Option<crate::dom::types::NodeId>,
}
impl<'de> serde::Deserialize<'de> for MoveToParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = MoveToParams;
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 = "targetNodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub target_node_id: crate::dom::types::NodeId,
#[serde(rename = "insertBeforeNodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub insert_before_node_id: Option<crate::dom::types::NodeId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(MoveToParams {
node_id: fields.node_id,
target_node_id: fields.target_node_id,
insert_before_node_id: fields.insert_before_node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct MoveTo;
#[derive(Debug, Clone, serde::Serialize)]
pub struct MoveToResponse {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for MoveToResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = MoveToResponse;
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(MoveToResponse {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for MoveTo {
type Params = MoveToParams;
type Response = MoveToResponse;
const METHOD: &'static str = "DOM.moveTo";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct PerformSearchParams {
#[serde(rename = "query")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub query: String,
#[serde(rename = "includeUserAgentShadowDOM")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_user_agent_shadow_dom: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for PerformSearchParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PerformSearchParams;
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 = "query")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub query: String,
#[serde(rename = "includeUserAgentShadowDOM")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_user_agent_shadow_dom: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PerformSearchParams {
query: fields.query,
include_user_agent_shadow_dom: fields.include_user_agent_shadow_dom,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct PerformSearch;
#[derive(Debug, Clone, serde::Serialize)]
pub struct PerformSearchResponse {
#[serde(rename = "searchId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub search_id: String,
#[serde(rename = "resultCount")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub result_count: i64,
}
impl<'de> serde::Deserialize<'de> for PerformSearchResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PerformSearchResponse;
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 = "searchId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub search_id: String,
#[serde(rename = "resultCount")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub result_count: i64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PerformSearchResponse {
search_id: fields.search_id,
result_count: fields.result_count,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for PerformSearch {
type Params = PerformSearchParams;
type Response = PerformSearchResponse;
const METHOD: &'static str = "DOM.performSearch";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct PushNodeByPathToFrontendParams {
#[serde(rename = "path")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub path: String,
}
impl<'de> serde::Deserialize<'de> for PushNodeByPathToFrontendParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PushNodeByPathToFrontendParams;
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 = "path")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub path: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PushNodeByPathToFrontendParams { path: fields.path })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct PushNodeByPathToFrontend;
#[derive(Debug, Clone, serde::Serialize)]
pub struct PushNodeByPathToFrontendResponse {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for PushNodeByPathToFrontendResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PushNodeByPathToFrontendResponse;
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(PushNodeByPathToFrontendResponse {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for PushNodeByPathToFrontend {
type Params = PushNodeByPathToFrontendParams;
type Response = PushNodeByPathToFrontendResponse;
const METHOD: &'static str = "DOM.pushNodeByPathToFrontend";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct PushNodesByBackendIdsToFrontendParams {
#[serde(rename = "backendNodeIds")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub backend_node_ids: Vec<crate::dom::types::BackendNodeId>,
}
impl<'de> serde::Deserialize<'de> for PushNodesByBackendIdsToFrontendParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PushNodesByBackendIdsToFrontendParams;
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 = "backendNodeIds")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub backend_node_ids: Vec<crate::dom::types::BackendNodeId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PushNodesByBackendIdsToFrontendParams {
backend_node_ids: fields.backend_node_ids,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct PushNodesByBackendIdsToFrontend;
#[derive(Debug, Clone, serde::Serialize)]
pub struct PushNodesByBackendIdsToFrontendResponse {
#[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 PushNodesByBackendIdsToFrontendResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PushNodesByBackendIdsToFrontendResponse;
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(PushNodesByBackendIdsToFrontendResponse {
node_ids: fields.node_ids,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for PushNodesByBackendIdsToFrontend {
type Params = PushNodesByBackendIdsToFrontendParams;
type Response = PushNodesByBackendIdsToFrontendResponse;
const METHOD: &'static str = "DOM.pushNodesByBackendIdsToFrontend";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct QuerySelectorParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "selector")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub selector: String,
}
impl<'de> serde::Deserialize<'de> for QuerySelectorParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = QuerySelectorParams;
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 = "selector")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub selector: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(QuerySelectorParams {
node_id: fields.node_id,
selector: fields.selector,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct QuerySelector;
#[derive(Debug, Clone, serde::Serialize)]
pub struct QuerySelectorResponse {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for QuerySelectorResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = QuerySelectorResponse;
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(QuerySelectorResponse {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for QuerySelector {
type Params = QuerySelectorParams;
type Response = QuerySelectorResponse;
const METHOD: &'static str = "DOM.querySelector";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct QuerySelectorAllParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "selector")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub selector: String,
}
impl<'de> serde::Deserialize<'de> for QuerySelectorAllParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = QuerySelectorAllParams;
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 = "selector")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub selector: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(QuerySelectorAllParams {
node_id: fields.node_id,
selector: fields.selector,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct QuerySelectorAll;
#[derive(Debug, Clone, serde::Serialize)]
pub struct QuerySelectorAllResponse {
#[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 QuerySelectorAllResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = QuerySelectorAllResponse;
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(QuerySelectorAllResponse {
node_ids: fields.node_ids,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for QuerySelectorAll {
type Params = QuerySelectorAllParams;
type Response = QuerySelectorAllResponse;
const METHOD: &'static str = "DOM.querySelectorAll";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct RedoParams {}
impl<'de> serde::Deserialize<'de> for RedoParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RedoParams;
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(RedoParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Redo;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RedoResponse {}
impl<'de> serde::Deserialize<'de> for RedoResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RedoResponse;
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(RedoResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Redo {
type Params = RedoParams;
type Response = RedoResponse;
const METHOD: &'static str = "DOM.redo";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveAttributeParams {
#[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 RemoveAttributeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveAttributeParams;
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(RemoveAttributeParams {
node_id: fields.node_id,
name: fields.name,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RemoveAttribute;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveAttributeResponse {}
impl<'de> serde::Deserialize<'de> for RemoveAttributeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveAttributeResponse;
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(RemoveAttributeResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RemoveAttribute {
type Params = RemoveAttributeParams;
type Response = RemoveAttributeResponse;
const METHOD: &'static str = "DOM.removeAttribute";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveNodeParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for RemoveNodeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveNodeParams;
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(RemoveNodeParams {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RemoveNode;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveNodeResponse {}
impl<'de> serde::Deserialize<'de> for RemoveNodeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveNodeResponse;
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(RemoveNodeResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RemoveNode {
type Params = RemoveNodeParams;
type Response = RemoveNodeResponse;
const METHOD: &'static str = "DOM.removeNode";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RequestChildNodesParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "depth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub depth: Option<i64>,
#[serde(rename = "pierce")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub pierce: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for RequestChildNodesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RequestChildNodesParams;
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 = "depth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub depth: Option<i64>,
#[serde(rename = "pierce")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub pierce: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RequestChildNodesParams {
node_id: fields.node_id,
depth: fields.depth,
pierce: fields.pierce,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RequestChildNodes;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RequestChildNodesResponse {}
impl<'de> serde::Deserialize<'de> for RequestChildNodesResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RequestChildNodesResponse;
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(RequestChildNodesResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RequestChildNodes {
type Params = RequestChildNodesParams;
type Response = RequestChildNodesResponse;
const METHOD: &'static str = "DOM.requestChildNodes";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RequestNodeParams {
#[serde(rename = "objectId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub object_id: crate::runtime::types::RemoteObjectId,
}
impl<'de> serde::Deserialize<'de> for RequestNodeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RequestNodeParams;
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 = "objectId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub object_id: crate::runtime::types::RemoteObjectId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RequestNodeParams {
object_id: fields.object_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RequestNode;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RequestNodeResponse {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for RequestNodeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RequestNodeResponse;
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(RequestNodeResponse {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RequestNode {
type Params = RequestNodeParams;
type Response = RequestNodeResponse;
const METHOD: &'static str = "DOM.requestNode";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct ResolveNodeParams {
#[serde(rename = "nodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectGroup")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_group: Option<String>,
#[serde(rename = "executionContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub execution_context_id: Option<crate::runtime::types::ExecutionContextId>,
}
impl<'de> serde::Deserialize<'de> for ResolveNodeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResolveNodeParams;
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(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectGroup")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_group: Option<String>,
#[serde(rename = "executionContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub execution_context_id: Option<crate::runtime::types::ExecutionContextId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ResolveNodeParams {
node_id: fields.node_id,
backend_node_id: fields.backend_node_id,
object_group: fields.object_group,
execution_context_id: fields.execution_context_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ResolveNode;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ResolveNodeResponse {
#[serde(rename = "object")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub object: crate::runtime::types::RemoteObject,
}
impl<'de> serde::Deserialize<'de> for ResolveNodeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResolveNodeResponse;
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 = "object")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub object: crate::runtime::types::RemoteObject,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ResolveNodeResponse {
object: fields.object,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ResolveNode {
type Params = ResolveNodeParams;
type Response = ResolveNodeResponse;
const METHOD: &'static str = "DOM.resolveNode";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct ScrollIntoViewIfNeededParams {
#[serde(rename = "nodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_id: Option<crate::runtime::types::RemoteObjectId>,
#[serde(rename = "rect")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub rect: Option<crate::dom::types::Rect>,
}
impl<'de> serde::Deserialize<'de> for ScrollIntoViewIfNeededParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ScrollIntoViewIfNeededParams;
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(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_id: Option<crate::runtime::types::RemoteObjectId>,
#[serde(rename = "rect")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub rect: Option<crate::dom::types::Rect>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ScrollIntoViewIfNeededParams {
node_id: fields.node_id,
backend_node_id: fields.backend_node_id,
object_id: fields.object_id,
rect: fields.rect,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ScrollIntoViewIfNeeded;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ScrollIntoViewIfNeededResponse {}
impl<'de> serde::Deserialize<'de> for ScrollIntoViewIfNeededResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ScrollIntoViewIfNeededResponse;
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(ScrollIntoViewIfNeededResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ScrollIntoViewIfNeeded {
type Params = ScrollIntoViewIfNeededParams;
type Response = ScrollIntoViewIfNeededResponse;
const METHOD: &'static str = "DOM.scrollIntoViewIfNeeded";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetAttributeValueParams {
#[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 SetAttributeValueParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetAttributeValueParams;
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(SetAttributeValueParams {
node_id: fields.node_id,
name: fields.name,
value: fields.value,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetAttributeValue;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetAttributeValueResponse {}
impl<'de> serde::Deserialize<'de> for SetAttributeValueResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetAttributeValueResponse;
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(SetAttributeValueResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetAttributeValue {
type Params = SetAttributeValueParams;
type Response = SetAttributeValueResponse;
const METHOD: &'static str = "DOM.setAttributeValue";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetAttributesAsTextParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "text")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub text: String,
#[serde(rename = "name")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub name: Option<String>,
}
impl<'de> serde::Deserialize<'de> for SetAttributesAsTextParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetAttributesAsTextParams;
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 = "text")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub text: String,
#[serde(rename = "name")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub name: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetAttributesAsTextParams {
node_id: fields.node_id,
text: fields.text,
name: fields.name,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetAttributesAsText;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetAttributesAsTextResponse {}
impl<'de> serde::Deserialize<'de> for SetAttributesAsTextResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetAttributesAsTextResponse;
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(SetAttributesAsTextResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetAttributesAsText {
type Params = SetAttributesAsTextParams;
type Response = SetAttributesAsTextResponse;
const METHOD: &'static str = "DOM.setAttributesAsText";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetFileInputFilesParams {
#[serde(rename = "files")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub files: Vec<String>,
#[serde(rename = "nodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_id: Option<crate::runtime::types::RemoteObjectId>,
}
impl<'de> serde::Deserialize<'de> for SetFileInputFilesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetFileInputFilesParams;
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 = "files")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub files: Vec<String>,
#[serde(rename = "nodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub node_id: Option<crate::dom::types::NodeId>,
#[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>,
#[serde(rename = "objectId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_id: Option<crate::runtime::types::RemoteObjectId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetFileInputFilesParams {
files: fields.files,
node_id: fields.node_id,
backend_node_id: fields.backend_node_id,
object_id: fields.object_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetFileInputFiles;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetFileInputFilesResponse {}
impl<'de> serde::Deserialize<'de> for SetFileInputFilesResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetFileInputFilesResponse;
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(SetFileInputFilesResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetFileInputFiles {
type Params = SetFileInputFilesParams;
type Response = SetFileInputFilesResponse;
const METHOD: &'static str = "DOM.setFileInputFiles";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetInspectedNodeParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for SetInspectedNodeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetInspectedNodeParams;
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(SetInspectedNodeParams {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetInspectedNode;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetInspectedNodeResponse {}
impl<'de> serde::Deserialize<'de> for SetInspectedNodeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetInspectedNodeResponse;
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(SetInspectedNodeResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetInspectedNode {
type Params = SetInspectedNodeParams;
type Response = SetInspectedNodeResponse;
const METHOD: &'static str = "DOM.setInspectedNode";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetNodeNameParams {
#[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 SetNodeNameParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetNodeNameParams;
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(SetNodeNameParams {
node_id: fields.node_id,
name: fields.name,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetNodeName;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetNodeNameResponse {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for SetNodeNameResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetNodeNameResponse;
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(SetNodeNameResponse {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetNodeName {
type Params = SetNodeNameParams;
type Response = SetNodeNameResponse;
const METHOD: &'static str = "DOM.setNodeName";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetNodeStackTracesEnabledParams {
#[serde(rename = "enable")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enable: bool,
}
impl<'de> serde::Deserialize<'de> for SetNodeStackTracesEnabledParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetNodeStackTracesEnabledParams;
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 = "enable")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enable: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetNodeStackTracesEnabledParams {
enable: fields.enable,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetNodeStackTracesEnabled;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetNodeStackTracesEnabledResponse {}
impl<'de> serde::Deserialize<'de> for SetNodeStackTracesEnabledResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetNodeStackTracesEnabledResponse;
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(SetNodeStackTracesEnabledResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetNodeStackTracesEnabled {
type Params = SetNodeStackTracesEnabledParams;
type Response = SetNodeStackTracesEnabledResponse;
const METHOD: &'static str = "DOM.setNodeStackTracesEnabled";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetNodeValueParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "value")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub value: String,
}
impl<'de> serde::Deserialize<'de> for SetNodeValueParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetNodeValueParams;
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 = "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(SetNodeValueParams {
node_id: fields.node_id,
value: fields.value,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetNodeValue;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetNodeValueResponse {}
impl<'de> serde::Deserialize<'de> for SetNodeValueResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetNodeValueResponse;
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(SetNodeValueResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetNodeValue {
type Params = SetNodeValueParams;
type Response = SetNodeValueResponse;
const METHOD: &'static str = "DOM.setNodeValue";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetOuterHtmlParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "outerHTML")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub outer_html: String,
}
impl<'de> serde::Deserialize<'de> for SetOuterHtmlParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetOuterHtmlParams;
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 = "outerHTML")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub outer_html: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetOuterHtmlParams {
node_id: fields.node_id,
outer_html: fields.outer_html,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetOuterHtml;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetOuterHtmlResponse {}
impl<'de> serde::Deserialize<'de> for SetOuterHtmlResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetOuterHtmlResponse;
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(SetOuterHtmlResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetOuterHtml {
type Params = SetOuterHtmlParams;
type Response = SetOuterHtmlResponse;
const METHOD: &'static str = "DOM.setOuterHTML";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct UndoParams {}
impl<'de> serde::Deserialize<'de> for UndoParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UndoParams;
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(UndoParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Undo;
#[derive(Debug, Clone, serde::Serialize)]
pub struct UndoResponse {}
impl<'de> serde::Deserialize<'de> for UndoResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UndoResponse;
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(UndoResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Undo {
type Params = UndoParams;
type Response = UndoResponse;
const METHOD: &'static str = "DOM.undo";
}