#[derive(Debug, Clone, serde::Serialize)]
pub struct GetEventListenersParams {
#[serde(rename = "objectId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub object_id: 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 GetEventListenersParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetEventListenersParams;
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,
#[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(GetEventListenersParams {
object_id: fields.object_id,
depth: fields.depth,
pierce: fields.pierce,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetEventListeners;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetEventListenersResponse {
#[serde(rename = "listeners")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub listeners: Vec<crate::dom_debugger::types::EventListener>,
}
impl<'de> serde::Deserialize<'de> for GetEventListenersResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetEventListenersResponse;
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 = "listeners")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub listeners: Vec<crate::dom_debugger::types::EventListener>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetEventListenersResponse {
listeners: fields.listeners,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetEventListeners {
type Params = GetEventListenersParams;
type Response = GetEventListenersResponse;
const METHOD: &'static str = "DOMDebugger.getEventListeners";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveDomBreakpointParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::dom_debugger::types::DomBreakpointType,
}
impl<'de> serde::Deserialize<'de> for RemoveDomBreakpointParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveDomBreakpointParams;
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 = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::dom_debugger::types::DomBreakpointType,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RemoveDomBreakpointParams {
node_id: fields.node_id,
r#type: fields.r#type,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RemoveDomBreakpoint;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveDomBreakpointResponse {}
impl<'de> serde::Deserialize<'de> for RemoveDomBreakpointResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveDomBreakpointResponse;
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(RemoveDomBreakpointResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RemoveDomBreakpoint {
type Params = RemoveDomBreakpointParams;
type Response = RemoveDomBreakpointResponse;
const METHOD: &'static str = "DOMDebugger.removeDOMBreakpoint";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveEventListenerBreakpointParams {
#[serde(rename = "eventName")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub event_name: String,
#[serde(rename = "targetName")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub target_name: Option<String>,
}
impl<'de> serde::Deserialize<'de> for RemoveEventListenerBreakpointParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveEventListenerBreakpointParams;
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 = "eventName")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub event_name: String,
#[serde(rename = "targetName")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub target_name: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RemoveEventListenerBreakpointParams {
event_name: fields.event_name,
target_name: fields.target_name,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RemoveEventListenerBreakpoint;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveEventListenerBreakpointResponse {}
impl<'de> serde::Deserialize<'de> for RemoveEventListenerBreakpointResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveEventListenerBreakpointResponse;
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(RemoveEventListenerBreakpointResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RemoveEventListenerBreakpoint {
type Params = RemoveEventListenerBreakpointParams;
type Response = RemoveEventListenerBreakpointResponse;
const METHOD: &'static str = "DOMDebugger.removeEventListenerBreakpoint";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveInstrumentationBreakpointParams {
#[serde(rename = "eventName")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub event_name: String,
}
impl<'de> serde::Deserialize<'de> for RemoveInstrumentationBreakpointParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveInstrumentationBreakpointParams;
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 = "eventName")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub event_name: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RemoveInstrumentationBreakpointParams {
event_name: fields.event_name,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RemoveInstrumentationBreakpoint;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveInstrumentationBreakpointResponse {}
impl<'de> serde::Deserialize<'de> for RemoveInstrumentationBreakpointResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveInstrumentationBreakpointResponse;
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(RemoveInstrumentationBreakpointResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RemoveInstrumentationBreakpoint {
type Params = RemoveInstrumentationBreakpointParams;
type Response = RemoveInstrumentationBreakpointResponse;
const METHOD: &'static str = "DOMDebugger.removeInstrumentationBreakpoint";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveXhrBreakpointParams {
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
}
impl<'de> serde::Deserialize<'de> for RemoveXhrBreakpointParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveXhrBreakpointParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RemoveXhrBreakpointParams { url: fields.url })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RemoveXhrBreakpoint;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveXhrBreakpointResponse {}
impl<'de> serde::Deserialize<'de> for RemoveXhrBreakpointResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveXhrBreakpointResponse;
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(RemoveXhrBreakpointResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RemoveXhrBreakpoint {
type Params = RemoveXhrBreakpointParams;
type Response = RemoveXhrBreakpointResponse;
const METHOD: &'static str = "DOMDebugger.removeXHRBreakpoint";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetBreakOnCspViolationParams {
#[serde(rename = "violationTypes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub violation_types: Vec<crate::dom_debugger::types::CspViolationType>,
}
impl<'de> serde::Deserialize<'de> for SetBreakOnCspViolationParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetBreakOnCspViolationParams;
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 = "violationTypes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub violation_types: Vec<crate::dom_debugger::types::CspViolationType>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetBreakOnCspViolationParams {
violation_types: fields.violation_types,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetBreakOnCspViolation;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetBreakOnCspViolationResponse {}
impl<'de> serde::Deserialize<'de> for SetBreakOnCspViolationResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetBreakOnCspViolationResponse;
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(SetBreakOnCspViolationResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetBreakOnCspViolation {
type Params = SetBreakOnCspViolationParams;
type Response = SetBreakOnCspViolationResponse;
const METHOD: &'static str = "DOMDebugger.setBreakOnCSPViolation";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDomBreakpointParams {
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::dom::types::NodeId,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::dom_debugger::types::DomBreakpointType,
}
impl<'de> serde::Deserialize<'de> for SetDomBreakpointParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDomBreakpointParams;
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 = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::dom_debugger::types::DomBreakpointType,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetDomBreakpointParams {
node_id: fields.node_id,
r#type: fields.r#type,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetDomBreakpoint;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDomBreakpointResponse {}
impl<'de> serde::Deserialize<'de> for SetDomBreakpointResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDomBreakpointResponse;
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(SetDomBreakpointResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetDomBreakpoint {
type Params = SetDomBreakpointParams;
type Response = SetDomBreakpointResponse;
const METHOD: &'static str = "DOMDebugger.setDOMBreakpoint";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetEventListenerBreakpointParams {
#[serde(rename = "eventName")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub event_name: String,
#[serde(rename = "targetName")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub target_name: Option<String>,
}
impl<'de> serde::Deserialize<'de> for SetEventListenerBreakpointParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetEventListenerBreakpointParams;
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 = "eventName")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub event_name: String,
#[serde(rename = "targetName")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub target_name: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetEventListenerBreakpointParams {
event_name: fields.event_name,
target_name: fields.target_name,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetEventListenerBreakpoint;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetEventListenerBreakpointResponse {}
impl<'de> serde::Deserialize<'de> for SetEventListenerBreakpointResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetEventListenerBreakpointResponse;
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(SetEventListenerBreakpointResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetEventListenerBreakpoint {
type Params = SetEventListenerBreakpointParams;
type Response = SetEventListenerBreakpointResponse;
const METHOD: &'static str = "DOMDebugger.setEventListenerBreakpoint";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetInstrumentationBreakpointParams {
#[serde(rename = "eventName")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub event_name: String,
}
impl<'de> serde::Deserialize<'de> for SetInstrumentationBreakpointParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetInstrumentationBreakpointParams;
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 = "eventName")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub event_name: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetInstrumentationBreakpointParams {
event_name: fields.event_name,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetInstrumentationBreakpoint;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetInstrumentationBreakpointResponse {}
impl<'de> serde::Deserialize<'de> for SetInstrumentationBreakpointResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetInstrumentationBreakpointResponse;
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(SetInstrumentationBreakpointResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetInstrumentationBreakpoint {
type Params = SetInstrumentationBreakpointParams;
type Response = SetInstrumentationBreakpointResponse;
const METHOD: &'static str = "DOMDebugger.setInstrumentationBreakpoint";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetXhrBreakpointParams {
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
}
impl<'de> serde::Deserialize<'de> for SetXhrBreakpointParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetXhrBreakpointParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetXhrBreakpointParams { url: fields.url })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetXhrBreakpoint;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetXhrBreakpointResponse {}
impl<'de> serde::Deserialize<'de> for SetXhrBreakpointResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetXhrBreakpointResponse;
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(SetXhrBreakpointResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetXhrBreakpoint {
type Params = SetXhrBreakpointParams;
type Response = SetXhrBreakpointResponse;
const METHOD: &'static str = "DOMDebugger.setXHRBreakpoint";
}