#[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 = "Overlay.disable";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct EnableParams {}
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 {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(EnableParams {})
}
}
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 = "Overlay.enable";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetGridHighlightObjectsForTestParams {
#[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 GetGridHighlightObjectsForTestParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetGridHighlightObjectsForTestParams;
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(GetGridHighlightObjectsForTestParams {
node_ids: fields.node_ids,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetGridHighlightObjectsForTest;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetGridHighlightObjectsForTestResponse {
#[serde(rename = "highlights")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub highlights: std::collections::BTreeMap<String, serde_json::Value>,
}
impl<'de> serde::Deserialize<'de> for GetGridHighlightObjectsForTestResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetGridHighlightObjectsForTestResponse;
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 = "highlights")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub highlights: std::collections::BTreeMap<String, serde_json::Value>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetGridHighlightObjectsForTestResponse {
highlights: fields.highlights,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetGridHighlightObjectsForTest {
type Params = GetGridHighlightObjectsForTestParams;
type Response = GetGridHighlightObjectsForTestResponse;
const METHOD: &'static str = "Overlay.getGridHighlightObjectsForTest";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetHighlightObjectForTestParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "includeDistance")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_distance: Option<bool>,
#[serde(rename = "includeStyle")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_style: Option<bool>,
#[serde(rename = "colorFormat")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub color_format: Option<crate::overlay::types::ColorFormat>,
#[serde(rename = "showAccessibilityInfo")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub show_accessibility_info: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for GetHighlightObjectForTestParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetHighlightObjectForTestParams;
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 = "includeDistance")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_distance: Option<bool>,
#[serde(rename = "includeStyle")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_style: Option<bool>,
#[serde(rename = "colorFormat")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub color_format: Option<crate::overlay::types::ColorFormat>,
#[serde(rename = "showAccessibilityInfo")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub show_accessibility_info: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetHighlightObjectForTestParams {
node_id: fields.node_id,
include_distance: fields.include_distance,
include_style: fields.include_style,
color_format: fields.color_format,
show_accessibility_info: fields.show_accessibility_info,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetHighlightObjectForTest;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetHighlightObjectForTestResponse {
#[serde(rename = "highlight")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub highlight: std::collections::BTreeMap<String, serde_json::Value>,
}
impl<'de> serde::Deserialize<'de> for GetHighlightObjectForTestResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetHighlightObjectForTestResponse;
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 = "highlight")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub highlight: std::collections::BTreeMap<String, serde_json::Value>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetHighlightObjectForTestResponse {
highlight: fields.highlight,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetHighlightObjectForTest {
type Params = GetHighlightObjectForTestParams;
type Response = GetHighlightObjectForTestResponse;
const METHOD: &'static str = "Overlay.getHighlightObjectForTest";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetSourceOrderHighlightObjectForTestParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
}
impl<'de> serde::Deserialize<'de> for GetSourceOrderHighlightObjectForTestParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetSourceOrderHighlightObjectForTestParams;
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(GetSourceOrderHighlightObjectForTestParams {
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetSourceOrderHighlightObjectForTest;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetSourceOrderHighlightObjectForTestResponse {
#[serde(rename = "highlight")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub highlight: std::collections::BTreeMap<String, serde_json::Value>,
}
impl<'de> serde::Deserialize<'de> for GetSourceOrderHighlightObjectForTestResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetSourceOrderHighlightObjectForTestResponse;
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 = "highlight")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub highlight: std::collections::BTreeMap<String, serde_json::Value>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetSourceOrderHighlightObjectForTestResponse {
highlight: fields.highlight,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetSourceOrderHighlightObjectForTest {
type Params = GetSourceOrderHighlightObjectForTestParams;
type Response = GetSourceOrderHighlightObjectForTestResponse;
const METHOD: &'static str = "Overlay.getSourceOrderHighlightObjectForTest";
}
#[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 = "Overlay.hideHighlight";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct HighlightFrameParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "contentColor")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub content_color: Option<crate::dom::types::Rgba>,
#[serde(rename = "contentOutlineColor")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub content_outline_color: Option<crate::dom::types::Rgba>,
}
impl<'de> serde::Deserialize<'de> for HighlightFrameParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = HighlightFrameParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "contentColor")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub content_color: Option<crate::dom::types::Rgba>,
#[serde(rename = "contentOutlineColor")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub content_outline_color: Option<crate::dom::types::Rgba>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(HighlightFrameParams {
frame_id: fields.frame_id,
content_color: fields.content_color,
content_outline_color: fields.content_outline_color,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct HighlightFrame;
#[derive(Debug, Clone, serde::Serialize)]
pub struct HighlightFrameResponse {}
impl<'de> serde::Deserialize<'de> for HighlightFrameResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = HighlightFrameResponse;
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(HighlightFrameResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for HighlightFrame {
type Params = HighlightFrameParams;
type Response = HighlightFrameResponse;
const METHOD: &'static str = "Overlay.highlightFrame";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct HighlightNodeParams {
#[serde(rename = "highlightConfig")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub highlight_config: crate::overlay::types::HighlightConfig,
#[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 = "selector")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub selector: Option<String>,
}
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 {
#[serde(rename = "highlightConfig")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub highlight_config: crate::overlay::types::HighlightConfig,
#[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 = "selector")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub selector: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(HighlightNodeParams {
highlight_config: fields.highlight_config,
node_id: fields.node_id,
backend_node_id: fields.backend_node_id,
object_id: fields.object_id,
selector: fields.selector,
})
}
}
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 = "Overlay.highlightNode";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct HighlightQuadParams {
#[serde(rename = "quad")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub quad: crate::dom::types::Quad,
#[serde(rename = "color")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub color: Option<crate::dom::types::Rgba>,
#[serde(rename = "outlineColor")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub outline_color: Option<crate::dom::types::Rgba>,
}
impl<'de> serde::Deserialize<'de> for HighlightQuadParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = HighlightQuadParams;
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 = "quad")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub quad: crate::dom::types::Quad,
#[serde(rename = "color")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub color: Option<crate::dom::types::Rgba>,
#[serde(rename = "outlineColor")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub outline_color: Option<crate::dom::types::Rgba>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(HighlightQuadParams {
quad: fields.quad,
color: fields.color,
outline_color: fields.outline_color,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct HighlightQuad;
#[derive(Debug, Clone, serde::Serialize)]
pub struct HighlightQuadResponse {}
impl<'de> serde::Deserialize<'de> for HighlightQuadResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = HighlightQuadResponse;
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(HighlightQuadResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for HighlightQuad {
type Params = HighlightQuadParams;
type Response = HighlightQuadResponse;
const METHOD: &'static str = "Overlay.highlightQuad";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct HighlightRectParams {
#[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 = "width")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub width: i64,
#[serde(rename = "height")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub height: i64,
#[serde(rename = "color")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub color: Option<crate::dom::types::Rgba>,
#[serde(rename = "outlineColor")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub outline_color: Option<crate::dom::types::Rgba>,
}
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 {
#[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 = "width")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub width: i64,
#[serde(rename = "height")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub height: i64,
#[serde(rename = "color")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub color: Option<crate::dom::types::Rgba>,
#[serde(rename = "outlineColor")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub outline_color: Option<crate::dom::types::Rgba>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(HighlightRectParams {
x: fields.x,
y: fields.y,
width: fields.width,
height: fields.height,
color: fields.color,
outline_color: fields.outline_color,
})
}
}
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 = "Overlay.highlightRect";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct HighlightSourceOrderParams {
#[serde(rename = "sourceOrderConfig")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source_order_config: crate::overlay::types::SourceOrderConfig,
#[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 HighlightSourceOrderParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = HighlightSourceOrderParams;
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 = "sourceOrderConfig")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source_order_config: crate::overlay::types::SourceOrderConfig,
#[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(HighlightSourceOrderParams {
source_order_config: fields.source_order_config,
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 HighlightSourceOrder;
#[derive(Debug, Clone, serde::Serialize)]
pub struct HighlightSourceOrderResponse {}
impl<'de> serde::Deserialize<'de> for HighlightSourceOrderResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = HighlightSourceOrderResponse;
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(HighlightSourceOrderResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for HighlightSourceOrder {
type Params = HighlightSourceOrderParams;
type Response = HighlightSourceOrderResponse;
const METHOD: &'static str = "Overlay.highlightSourceOrder";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetInspectModeParams {
#[serde(rename = "mode")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub mode: crate::overlay::types::InspectMode,
#[serde(rename = "highlightConfig")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub highlight_config: Option<crate::overlay::types::HighlightConfig>,
}
impl<'de> serde::Deserialize<'de> for SetInspectModeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetInspectModeParams;
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 = "mode")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub mode: crate::overlay::types::InspectMode,
#[serde(rename = "highlightConfig")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub highlight_config: Option<crate::overlay::types::HighlightConfig>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetInspectModeParams {
mode: fields.mode,
highlight_config: fields.highlight_config,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetInspectMode;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetInspectModeResponse {}
impl<'de> serde::Deserialize<'de> for SetInspectModeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetInspectModeResponse;
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(SetInspectModeResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetInspectMode {
type Params = SetInspectModeParams;
type Response = SetInspectModeResponse;
const METHOD: &'static str = "Overlay.setInspectMode";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct SetPausedInDebuggerMessageParams {
#[serde(rename = "message")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub message: Option<String>,
}
impl<'de> serde::Deserialize<'de> for SetPausedInDebuggerMessageParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPausedInDebuggerMessageParams;
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 = "message")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub message: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetPausedInDebuggerMessageParams {
message: fields.message,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetPausedInDebuggerMessage;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPausedInDebuggerMessageResponse {}
impl<'de> serde::Deserialize<'de> for SetPausedInDebuggerMessageResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPausedInDebuggerMessageResponse;
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(SetPausedInDebuggerMessageResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetPausedInDebuggerMessage {
type Params = SetPausedInDebuggerMessageParams;
type Response = SetPausedInDebuggerMessageResponse;
const METHOD: &'static str = "Overlay.setPausedInDebuggerMessage";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowAdHighlightsParams {
#[serde(rename = "show")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub show: bool,
}
impl<'de> serde::Deserialize<'de> for SetShowAdHighlightsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowAdHighlightsParams;
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 = "show")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub show: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowAdHighlightsParams { show: fields.show })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowAdHighlights;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowAdHighlightsResponse {}
impl<'de> serde::Deserialize<'de> for SetShowAdHighlightsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowAdHighlightsResponse;
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(SetShowAdHighlightsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowAdHighlights {
type Params = SetShowAdHighlightsParams;
type Response = SetShowAdHighlightsResponse;
const METHOD: &'static str = "Overlay.setShowAdHighlights";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowContainerQueryOverlaysParams {
#[serde(rename = "containerQueryHighlightConfigs")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub container_query_highlight_configs:
Vec<crate::overlay::types::ContainerQueryHighlightConfig>,
}
impl<'de> serde::Deserialize<'de> for SetShowContainerQueryOverlaysParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowContainerQueryOverlaysParams;
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 = "containerQueryHighlightConfigs")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub container_query_highlight_configs:
Vec<crate::overlay::types::ContainerQueryHighlightConfig>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowContainerQueryOverlaysParams {
container_query_highlight_configs: fields.container_query_highlight_configs,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowContainerQueryOverlays;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowContainerQueryOverlaysResponse {}
impl<'de> serde::Deserialize<'de> for SetShowContainerQueryOverlaysResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowContainerQueryOverlaysResponse;
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(SetShowContainerQueryOverlaysResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowContainerQueryOverlays {
type Params = SetShowContainerQueryOverlaysParams;
type Response = SetShowContainerQueryOverlaysResponse;
const METHOD: &'static str = "Overlay.setShowContainerQueryOverlays";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowDebugBordersParams {
#[serde(rename = "show")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub show: bool,
}
impl<'de> serde::Deserialize<'de> for SetShowDebugBordersParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowDebugBordersParams;
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 = "show")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub show: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowDebugBordersParams { show: fields.show })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowDebugBorders;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowDebugBordersResponse {}
impl<'de> serde::Deserialize<'de> for SetShowDebugBordersResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowDebugBordersResponse;
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(SetShowDebugBordersResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowDebugBorders {
type Params = SetShowDebugBordersParams;
type Response = SetShowDebugBordersResponse;
const METHOD: &'static str = "Overlay.setShowDebugBorders";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct SetShowDisplayCutoutParams {
#[serde(rename = "displayCutoutConfig")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub display_cutout_config: Option<crate::overlay::types::DisplayCutoutConfig>,
}
impl<'de> serde::Deserialize<'de> for SetShowDisplayCutoutParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowDisplayCutoutParams;
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 = "displayCutoutConfig")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub display_cutout_config: Option<crate::overlay::types::DisplayCutoutConfig>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowDisplayCutoutParams {
display_cutout_config: fields.display_cutout_config,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowDisplayCutout;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowDisplayCutoutResponse {}
impl<'de> serde::Deserialize<'de> for SetShowDisplayCutoutResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowDisplayCutoutResponse;
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(SetShowDisplayCutoutResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowDisplayCutout {
type Params = SetShowDisplayCutoutParams;
type Response = SetShowDisplayCutoutResponse;
const METHOD: &'static str = "Overlay.setShowDisplayCutout";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowFpsCounterParams {
#[serde(rename = "show")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub show: bool,
}
impl<'de> serde::Deserialize<'de> for SetShowFpsCounterParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowFpsCounterParams;
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 = "show")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub show: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowFpsCounterParams { show: fields.show })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowFpsCounter;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowFpsCounterResponse {}
impl<'de> serde::Deserialize<'de> for SetShowFpsCounterResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowFpsCounterResponse;
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(SetShowFpsCounterResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowFpsCounter {
type Params = SetShowFpsCounterParams;
type Response = SetShowFpsCounterResponse;
const METHOD: &'static str = "Overlay.setShowFPSCounter";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowFlexOverlaysParams {
#[serde(rename = "flexNodeHighlightConfigs")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub flex_node_highlight_configs: Vec<crate::overlay::types::FlexNodeHighlightConfig>,
}
impl<'de> serde::Deserialize<'de> for SetShowFlexOverlaysParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowFlexOverlaysParams;
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 = "flexNodeHighlightConfigs")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub flex_node_highlight_configs:
Vec<crate::overlay::types::FlexNodeHighlightConfig>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowFlexOverlaysParams {
flex_node_highlight_configs: fields.flex_node_highlight_configs,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowFlexOverlays;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowFlexOverlaysResponse {}
impl<'de> serde::Deserialize<'de> for SetShowFlexOverlaysResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowFlexOverlaysResponse;
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(SetShowFlexOverlaysResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowFlexOverlays {
type Params = SetShowFlexOverlaysParams;
type Response = SetShowFlexOverlaysResponse;
const METHOD: &'static str = "Overlay.setShowFlexOverlays";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowGridOverlaysParams {
#[serde(rename = "gridNodeHighlightConfigs")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub grid_node_highlight_configs: Vec<crate::overlay::types::GridNodeHighlightConfig>,
}
impl<'de> serde::Deserialize<'de> for SetShowGridOverlaysParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowGridOverlaysParams;
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 = "gridNodeHighlightConfigs")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub grid_node_highlight_configs:
Vec<crate::overlay::types::GridNodeHighlightConfig>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowGridOverlaysParams {
grid_node_highlight_configs: fields.grid_node_highlight_configs,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowGridOverlays;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowGridOverlaysResponse {}
impl<'de> serde::Deserialize<'de> for SetShowGridOverlaysResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowGridOverlaysResponse;
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(SetShowGridOverlaysResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowGridOverlays {
type Params = SetShowGridOverlaysParams;
type Response = SetShowGridOverlaysResponse;
const METHOD: &'static str = "Overlay.setShowGridOverlays";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct SetShowHingeParams {
#[serde(rename = "hingeConfig")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub hinge_config: Option<crate::overlay::types::HingeConfig>,
}
impl<'de> serde::Deserialize<'de> for SetShowHingeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowHingeParams;
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 = "hingeConfig")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub hinge_config: Option<crate::overlay::types::HingeConfig>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowHingeParams {
hinge_config: fields.hinge_config,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowHinge;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowHingeResponse {}
impl<'de> serde::Deserialize<'de> for SetShowHingeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowHingeResponse;
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(SetShowHingeResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowHinge {
type Params = SetShowHingeParams;
type Response = SetShowHingeResponse;
const METHOD: &'static str = "Overlay.setShowHinge";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowHitTestBordersParams {
#[serde(rename = "show")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub show: bool,
}
impl<'de> serde::Deserialize<'de> for SetShowHitTestBordersParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowHitTestBordersParams;
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 = "show")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub show: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowHitTestBordersParams { show: fields.show })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowHitTestBorders;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowHitTestBordersResponse {}
impl<'de> serde::Deserialize<'de> for SetShowHitTestBordersResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowHitTestBordersResponse;
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(SetShowHitTestBordersResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowHitTestBorders {
type Params = SetShowHitTestBordersParams;
type Response = SetShowHitTestBordersResponse;
const METHOD: &'static str = "Overlay.setShowHitTestBorders";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowInspectedElementAnchorParams {
#[serde(rename = "inspectedElementAnchorConfig")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub inspected_element_anchor_config: crate::overlay::types::InspectedElementAnchorConfig,
}
impl<'de> serde::Deserialize<'de> for SetShowInspectedElementAnchorParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowInspectedElementAnchorParams;
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 = "inspectedElementAnchorConfig")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub inspected_element_anchor_config:
crate::overlay::types::InspectedElementAnchorConfig,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowInspectedElementAnchorParams {
inspected_element_anchor_config: fields.inspected_element_anchor_config,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowInspectedElementAnchor;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowInspectedElementAnchorResponse {}
impl<'de> serde::Deserialize<'de> for SetShowInspectedElementAnchorResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowInspectedElementAnchorResponse;
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(SetShowInspectedElementAnchorResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowInspectedElementAnchor {
type Params = SetShowInspectedElementAnchorParams;
type Response = SetShowInspectedElementAnchorResponse;
const METHOD: &'static str = "Overlay.setShowInspectedElementAnchor";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowIsolatedElementsParams {
#[serde(rename = "isolatedElementHighlightConfigs")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub isolated_element_highlight_configs:
Vec<crate::overlay::types::IsolatedElementHighlightConfig>,
}
impl<'de> serde::Deserialize<'de> for SetShowIsolatedElementsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowIsolatedElementsParams;
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 = "isolatedElementHighlightConfigs")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub isolated_element_highlight_configs:
Vec<crate::overlay::types::IsolatedElementHighlightConfig>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowIsolatedElementsParams {
isolated_element_highlight_configs: fields.isolated_element_highlight_configs,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowIsolatedElements;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowIsolatedElementsResponse {}
impl<'de> serde::Deserialize<'de> for SetShowIsolatedElementsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowIsolatedElementsResponse;
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(SetShowIsolatedElementsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowIsolatedElements {
type Params = SetShowIsolatedElementsParams;
type Response = SetShowIsolatedElementsResponse;
const METHOD: &'static str = "Overlay.setShowIsolatedElements";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowLayoutShiftRegionsParams {
#[serde(rename = "result")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub result: bool,
}
impl<'de> serde::Deserialize<'de> for SetShowLayoutShiftRegionsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowLayoutShiftRegionsParams;
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 = "result")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub result: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowLayoutShiftRegionsParams {
result: fields.result,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowLayoutShiftRegions;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowLayoutShiftRegionsResponse {}
impl<'de> serde::Deserialize<'de> for SetShowLayoutShiftRegionsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowLayoutShiftRegionsResponse;
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(SetShowLayoutShiftRegionsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowLayoutShiftRegions {
type Params = SetShowLayoutShiftRegionsParams;
type Response = SetShowLayoutShiftRegionsResponse;
const METHOD: &'static str = "Overlay.setShowLayoutShiftRegions";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowPaintRectsParams {
#[serde(rename = "result")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub result: bool,
}
impl<'de> serde::Deserialize<'de> for SetShowPaintRectsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowPaintRectsParams;
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 = "result")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub result: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowPaintRectsParams {
result: fields.result,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowPaintRects;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowPaintRectsResponse {}
impl<'de> serde::Deserialize<'de> for SetShowPaintRectsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowPaintRectsResponse;
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(SetShowPaintRectsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowPaintRects {
type Params = SetShowPaintRectsParams;
type Response = SetShowPaintRectsResponse;
const METHOD: &'static str = "Overlay.setShowPaintRects";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowScrollBottleneckRectsParams {
#[serde(rename = "show")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub show: bool,
}
impl<'de> serde::Deserialize<'de> for SetShowScrollBottleneckRectsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowScrollBottleneckRectsParams;
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 = "show")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub show: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowScrollBottleneckRectsParams { show: fields.show })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowScrollBottleneckRects;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowScrollBottleneckRectsResponse {}
impl<'de> serde::Deserialize<'de> for SetShowScrollBottleneckRectsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowScrollBottleneckRectsResponse;
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(SetShowScrollBottleneckRectsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowScrollBottleneckRects {
type Params = SetShowScrollBottleneckRectsParams;
type Response = SetShowScrollBottleneckRectsResponse;
const METHOD: &'static str = "Overlay.setShowScrollBottleneckRects";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowScrollSnapOverlaysParams {
#[serde(rename = "scrollSnapHighlightConfigs")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub scroll_snap_highlight_configs: Vec<crate::overlay::types::ScrollSnapHighlightConfig>,
}
impl<'de> serde::Deserialize<'de> for SetShowScrollSnapOverlaysParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowScrollSnapOverlaysParams;
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 = "scrollSnapHighlightConfigs")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub scroll_snap_highlight_configs:
Vec<crate::overlay::types::ScrollSnapHighlightConfig>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowScrollSnapOverlaysParams {
scroll_snap_highlight_configs: fields.scroll_snap_highlight_configs,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowScrollSnapOverlays;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowScrollSnapOverlaysResponse {}
impl<'de> serde::Deserialize<'de> for SetShowScrollSnapOverlaysResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowScrollSnapOverlaysResponse;
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(SetShowScrollSnapOverlaysResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowScrollSnapOverlays {
type Params = SetShowScrollSnapOverlaysParams;
type Response = SetShowScrollSnapOverlaysResponse;
const METHOD: &'static str = "Overlay.setShowScrollSnapOverlays";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowViewportSizeOnResizeParams {
#[serde(rename = "show")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub show: bool,
}
impl<'de> serde::Deserialize<'de> for SetShowViewportSizeOnResizeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowViewportSizeOnResizeParams;
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 = "show")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub show: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowViewportSizeOnResizeParams { show: fields.show })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowViewportSizeOnResize;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowViewportSizeOnResizeResponse {}
impl<'de> serde::Deserialize<'de> for SetShowViewportSizeOnResizeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowViewportSizeOnResizeResponse;
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(SetShowViewportSizeOnResizeResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowViewportSizeOnResize {
type Params = SetShowViewportSizeOnResizeParams;
type Response = SetShowViewportSizeOnResizeResponse;
const METHOD: &'static str = "Overlay.setShowViewportSizeOnResize";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowWebVitalsParams {
#[serde(rename = "show")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub show: bool,
}
impl<'de> serde::Deserialize<'de> for SetShowWebVitalsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowWebVitalsParams;
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 = "show")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub show: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowWebVitalsParams { show: fields.show })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowWebVitals;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowWebVitalsResponse {}
impl<'de> serde::Deserialize<'de> for SetShowWebVitalsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowWebVitalsResponse;
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(SetShowWebVitalsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowWebVitals {
type Params = SetShowWebVitalsParams;
type Response = SetShowWebVitalsResponse;
const METHOD: &'static str = "Overlay.setShowWebVitals";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct SetShowWindowControlsOverlayParams {
#[serde(rename = "windowControlsOverlayConfig")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub window_controls_overlay_config: Option<crate::overlay::types::WindowControlsOverlayConfig>,
}
impl<'de> serde::Deserialize<'de> for SetShowWindowControlsOverlayParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowWindowControlsOverlayParams;
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 = "windowControlsOverlayConfig")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub window_controls_overlay_config:
Option<crate::overlay::types::WindowControlsOverlayConfig>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetShowWindowControlsOverlayParams {
window_controls_overlay_config: fields.window_controls_overlay_config,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetShowWindowControlsOverlay;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetShowWindowControlsOverlayResponse {}
impl<'de> serde::Deserialize<'de> for SetShowWindowControlsOverlayResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetShowWindowControlsOverlayResponse;
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(SetShowWindowControlsOverlayResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetShowWindowControlsOverlay {
type Params = SetShowWindowControlsOverlayParams;
type Response = SetShowWindowControlsOverlayResponse;
const METHOD: &'static str = "Overlay.setShowWindowControlsOverlay";
}