#[derive(Debug, Clone, serde::Serialize)]
pub struct AddCompilationCacheParams {
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
}
impl<'de> serde::Deserialize<'de> for AddCompilationCacheParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddCompilationCacheParams;
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,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddCompilationCacheParams {
url: fields.url,
data: fields.data,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AddCompilationCache;
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddCompilationCacheResponse {}
impl<'de> serde::Deserialize<'de> for AddCompilationCacheResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddCompilationCacheResponse;
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(AddCompilationCacheResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for AddCompilationCache {
type Params = AddCompilationCacheParams;
type Response = AddCompilationCacheResponse;
const METHOD: &'static str = "Page.addCompilationCache";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddScriptToEvaluateOnLoadParams {
#[serde(rename = "scriptSource")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub script_source: String,
}
impl<'de> serde::Deserialize<'de> for AddScriptToEvaluateOnLoadParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddScriptToEvaluateOnLoadParams;
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 = "scriptSource")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub script_source: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddScriptToEvaluateOnLoadParams {
script_source: fields.script_source,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AddScriptToEvaluateOnLoad;
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddScriptToEvaluateOnLoadResponse {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::page::types::ScriptIdentifier,
}
impl<'de> serde::Deserialize<'de> for AddScriptToEvaluateOnLoadResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddScriptToEvaluateOnLoadResponse;
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 = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::page::types::ScriptIdentifier,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddScriptToEvaluateOnLoadResponse {
identifier: fields.identifier,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for AddScriptToEvaluateOnLoad {
type Params = AddScriptToEvaluateOnLoadParams;
type Response = AddScriptToEvaluateOnLoadResponse;
const METHOD: &'static str = "Page.addScriptToEvaluateOnLoad";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddScriptToEvaluateOnNewDocumentParams {
#[serde(rename = "source")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source: String,
#[serde(rename = "worldName")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub world_name: Option<String>,
#[serde(rename = "includeCommandLineAPI")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_command_line_api: Option<bool>,
#[serde(rename = "runImmediately")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub run_immediately: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for AddScriptToEvaluateOnNewDocumentParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddScriptToEvaluateOnNewDocumentParams;
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 = "source")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source: String,
#[serde(rename = "worldName")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub world_name: Option<String>,
#[serde(rename = "includeCommandLineAPI")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_command_line_api: Option<bool>,
#[serde(rename = "runImmediately")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub run_immediately: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddScriptToEvaluateOnNewDocumentParams {
source: fields.source,
world_name: fields.world_name,
include_command_line_api: fields.include_command_line_api,
run_immediately: fields.run_immediately,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AddScriptToEvaluateOnNewDocument;
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddScriptToEvaluateOnNewDocumentResponse {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::page::types::ScriptIdentifier,
}
impl<'de> serde::Deserialize<'de> for AddScriptToEvaluateOnNewDocumentResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddScriptToEvaluateOnNewDocumentResponse;
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 = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::page::types::ScriptIdentifier,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddScriptToEvaluateOnNewDocumentResponse {
identifier: fields.identifier,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for AddScriptToEvaluateOnNewDocument {
type Params = AddScriptToEvaluateOnNewDocumentParams;
type Response = AddScriptToEvaluateOnNewDocumentResponse;
const METHOD: &'static str = "Page.addScriptToEvaluateOnNewDocument";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct BringToFrontParams {}
impl<'de> serde::Deserialize<'de> for BringToFrontParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = BringToFrontParams;
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(BringToFrontParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct BringToFront;
#[derive(Debug, Clone, serde::Serialize)]
pub struct BringToFrontResponse {}
impl<'de> serde::Deserialize<'de> for BringToFrontResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = BringToFrontResponse;
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(BringToFrontResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for BringToFront {
type Params = BringToFrontParams;
type Response = BringToFrontResponse;
const METHOD: &'static str = "Page.bringToFront";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum CaptureScreenshotParamsFormat {
Jpeg,
Png,
Webp,
Unknown(String),
}
impl CaptureScreenshotParamsFormat {
pub fn as_str(&self) -> &str {
match self {
Self::Jpeg => "jpeg",
Self::Png => "png",
Self::Webp => "webp",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for CaptureScreenshotParamsFormat {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for CaptureScreenshotParamsFormat {
fn from(value: String) -> Self {
match value.as_str() {
"jpeg" => CaptureScreenshotParamsFormat::Jpeg,
"png" => CaptureScreenshotParamsFormat::Png,
"webp" => CaptureScreenshotParamsFormat::Webp,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for CaptureScreenshotParamsFormat {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for CaptureScreenshotParamsFormat {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CaptureScreenshotParamsFormat;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议字符串枚举")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
Ok(match v {
"jpeg" => CaptureScreenshotParamsFormat::Jpeg,
"png" => CaptureScreenshotParamsFormat::Png,
"webp" => CaptureScreenshotParamsFormat::Webp,
_ => CaptureScreenshotParamsFormat::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(CaptureScreenshotParamsFormat::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct CaptureScreenshotParams {
#[serde(rename = "format")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub format: Option<CaptureScreenshotParamsFormat>,
#[serde(rename = "quality")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub quality: Option<i64>,
#[serde(rename = "clip")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub clip: Option<crate::page::types::Viewport>,
#[serde(rename = "fromSurface")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub from_surface: Option<bool>,
#[serde(rename = "captureBeyondViewport")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub capture_beyond_viewport: Option<bool>,
#[serde(rename = "optimizeForSpeed")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub optimize_for_speed: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for CaptureScreenshotParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CaptureScreenshotParams;
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 = "format")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub format: Option<CaptureScreenshotParamsFormat>,
#[serde(rename = "quality")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub quality: Option<i64>,
#[serde(rename = "clip")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub clip: Option<crate::page::types::Viewport>,
#[serde(rename = "fromSurface")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub from_surface: Option<bool>,
#[serde(rename = "captureBeyondViewport")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub capture_beyond_viewport: Option<bool>,
#[serde(rename = "optimizeForSpeed")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub optimize_for_speed: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CaptureScreenshotParams {
format: fields.format,
quality: fields.quality,
clip: fields.clip,
from_surface: fields.from_surface,
capture_beyond_viewport: fields.capture_beyond_viewport,
optimize_for_speed: fields.optimize_for_speed,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct CaptureScreenshot;
#[derive(Debug, Clone, serde::Serialize)]
pub struct CaptureScreenshotResponse {
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
}
impl<'de> serde::Deserialize<'de> for CaptureScreenshotResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CaptureScreenshotResponse;
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 = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CaptureScreenshotResponse { data: fields.data })
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for CaptureScreenshot {
type Params = CaptureScreenshotParams;
type Response = CaptureScreenshotResponse;
const METHOD: &'static str = "Page.captureScreenshot";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum CaptureSnapshotParamsFormat {
Mhtml,
Unknown(String),
}
impl CaptureSnapshotParamsFormat {
pub fn as_str(&self) -> &str {
match self {
Self::Mhtml => "mhtml",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for CaptureSnapshotParamsFormat {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for CaptureSnapshotParamsFormat {
fn from(value: String) -> Self {
match value.as_str() {
"mhtml" => CaptureSnapshotParamsFormat::Mhtml,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for CaptureSnapshotParamsFormat {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for CaptureSnapshotParamsFormat {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CaptureSnapshotParamsFormat;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议字符串枚举")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
Ok(match v {
"mhtml" => CaptureSnapshotParamsFormat::Mhtml,
_ => CaptureSnapshotParamsFormat::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(CaptureSnapshotParamsFormat::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct CaptureSnapshotParams {
#[serde(rename = "format")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub format: Option<CaptureSnapshotParamsFormat>,
}
impl<'de> serde::Deserialize<'de> for CaptureSnapshotParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CaptureSnapshotParams;
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 = "format")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub format: Option<CaptureSnapshotParamsFormat>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CaptureSnapshotParams {
format: fields.format,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct CaptureSnapshot;
#[derive(Debug, Clone, serde::Serialize)]
pub struct CaptureSnapshotResponse {
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
}
impl<'de> serde::Deserialize<'de> for CaptureSnapshotResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CaptureSnapshotResponse;
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 = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CaptureSnapshotResponse { data: fields.data })
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for CaptureSnapshot {
type Params = CaptureSnapshotParams;
type Response = CaptureSnapshotResponse;
const METHOD: &'static str = "Page.captureSnapshot";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct ClearCompilationCacheParams {}
impl<'de> serde::Deserialize<'de> for ClearCompilationCacheParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearCompilationCacheParams;
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(ClearCompilationCacheParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ClearCompilationCache;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearCompilationCacheResponse {}
impl<'de> serde::Deserialize<'de> for ClearCompilationCacheResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearCompilationCacheResponse;
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(ClearCompilationCacheResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ClearCompilationCache {
type Params = ClearCompilationCacheParams;
type Response = ClearCompilationCacheResponse;
const METHOD: &'static str = "Page.clearCompilationCache";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct ClearDeviceMetricsOverrideParams {}
impl<'de> serde::Deserialize<'de> for ClearDeviceMetricsOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearDeviceMetricsOverrideParams;
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(ClearDeviceMetricsOverrideParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ClearDeviceMetricsOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearDeviceMetricsOverrideResponse {}
impl<'de> serde::Deserialize<'de> for ClearDeviceMetricsOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearDeviceMetricsOverrideResponse;
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(ClearDeviceMetricsOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ClearDeviceMetricsOverride {
type Params = ClearDeviceMetricsOverrideParams;
type Response = ClearDeviceMetricsOverrideResponse;
const METHOD: &'static str = "Page.clearDeviceMetricsOverride";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct ClearDeviceOrientationOverrideParams {}
impl<'de> serde::Deserialize<'de> for ClearDeviceOrientationOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearDeviceOrientationOverrideParams;
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(ClearDeviceOrientationOverrideParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ClearDeviceOrientationOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearDeviceOrientationOverrideResponse {}
impl<'de> serde::Deserialize<'de> for ClearDeviceOrientationOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearDeviceOrientationOverrideResponse;
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(ClearDeviceOrientationOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ClearDeviceOrientationOverride {
type Params = ClearDeviceOrientationOverrideParams;
type Response = ClearDeviceOrientationOverrideResponse;
const METHOD: &'static str = "Page.clearDeviceOrientationOverride";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct ClearGeolocationOverrideParams {}
impl<'de> serde::Deserialize<'de> for ClearGeolocationOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearGeolocationOverrideParams;
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(ClearGeolocationOverrideParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ClearGeolocationOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearGeolocationOverrideResponse {}
impl<'de> serde::Deserialize<'de> for ClearGeolocationOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearGeolocationOverrideResponse;
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(ClearGeolocationOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ClearGeolocationOverride {
type Params = ClearGeolocationOverrideParams;
type Response = ClearGeolocationOverrideResponse;
const METHOD: &'static str = "Page.clearGeolocationOverride";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct CloseParams {}
impl<'de> serde::Deserialize<'de> for CloseParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CloseParams;
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(CloseParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Close;
#[derive(Debug, Clone, serde::Serialize)]
pub struct CloseResponse {}
impl<'de> serde::Deserialize<'de> for CloseResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CloseResponse;
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(CloseResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Close {
type Params = CloseParams;
type Response = CloseResponse;
const METHOD: &'static str = "Page.close";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct CrashParams {}
impl<'de> serde::Deserialize<'de> for CrashParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CrashParams;
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(CrashParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Crash;
#[derive(Debug, Clone, serde::Serialize)]
pub struct CrashResponse {}
impl<'de> serde::Deserialize<'de> for CrashResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CrashResponse;
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(CrashResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Crash {
type Params = CrashParams;
type Response = CrashResponse;
const METHOD: &'static str = "Page.crash";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct CreateIsolatedWorldParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "worldName")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub world_name: Option<String>,
#[serde(rename = "grantUniveralAccess")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub grant_univeral_access: Option<bool>,
#[serde(rename = "contentSecurityPolicy")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub content_security_policy: Option<String>,
}
impl<'de> serde::Deserialize<'de> for CreateIsolatedWorldParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CreateIsolatedWorldParams;
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 = "worldName")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub world_name: Option<String>,
#[serde(rename = "grantUniveralAccess")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub grant_univeral_access: Option<bool>,
#[serde(rename = "contentSecurityPolicy")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub content_security_policy: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CreateIsolatedWorldParams {
frame_id: fields.frame_id,
world_name: fields.world_name,
grant_univeral_access: fields.grant_univeral_access,
content_security_policy: fields.content_security_policy,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct CreateIsolatedWorld;
#[derive(Debug, Clone, serde::Serialize)]
pub struct CreateIsolatedWorldResponse {
#[serde(rename = "executionContextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub execution_context_id: crate::runtime::types::ExecutionContextId,
}
impl<'de> serde::Deserialize<'de> for CreateIsolatedWorldResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CreateIsolatedWorldResponse;
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 = "executionContextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub execution_context_id: crate::runtime::types::ExecutionContextId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CreateIsolatedWorldResponse {
execution_context_id: fields.execution_context_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for CreateIsolatedWorld {
type Params = CreateIsolatedWorldParams;
type Response = CreateIsolatedWorldResponse;
const METHOD: &'static str = "Page.createIsolatedWorld";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DeleteCookieParams {
#[serde(rename = "cookieName")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cookie_name: String,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
}
impl<'de> serde::Deserialize<'de> for DeleteCookieParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DeleteCookieParams;
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 = "cookieName")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cookie_name: String,
#[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(DeleteCookieParams {
cookie_name: fields.cookie_name,
url: fields.url,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DeleteCookie;
#[derive(Debug, Clone, serde::Serialize)]
pub struct DeleteCookieResponse {}
impl<'de> serde::Deserialize<'de> for DeleteCookieResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DeleteCookieResponse;
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(DeleteCookieResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for DeleteCookie {
type Params = DeleteCookieParams;
type Response = DeleteCookieResponse;
const METHOD: &'static str = "Page.deleteCookie";
}
#[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 = "Page.disable";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct EnableParams {
#[serde(rename = "enableFileChooserOpenedEvent")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub enable_file_chooser_opened_event: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for EnableParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = EnableParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "enableFileChooserOpenedEvent")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub enable_file_chooser_opened_event: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(EnableParams {
enable_file_chooser_opened_event: fields.enable_file_chooser_opened_event,
})
}
}
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 = "Page.enable";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GenerateTestReportParams {
#[serde(rename = "message")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub message: String,
#[serde(rename = "group")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub group: Option<String>,
}
impl<'de> serde::Deserialize<'de> for GenerateTestReportParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GenerateTestReportParams;
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(deserialize_with = "ydp_core::binding_support::required")]
pub message: String,
#[serde(rename = "group")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub group: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GenerateTestReportParams {
message: fields.message,
group: fields.group,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GenerateTestReport;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GenerateTestReportResponse {}
impl<'de> serde::Deserialize<'de> for GenerateTestReportResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GenerateTestReportResponse;
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(GenerateTestReportResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GenerateTestReport {
type Params = GenerateTestReportParams;
type Response = GenerateTestReportResponse;
const METHOD: &'static str = "Page.generateTestReport";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetAdScriptAncestryParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
impl<'de> serde::Deserialize<'de> for GetAdScriptAncestryParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetAdScriptAncestryParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetAdScriptAncestryParams {
frame_id: fields.frame_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetAdScriptAncestry;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetAdScriptAncestryResponse {
#[serde(rename = "adScriptAncestry")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub ad_script_ancestry: Option<crate::network::types::AdAncestry>,
}
impl<'de> serde::Deserialize<'de> for GetAdScriptAncestryResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetAdScriptAncestryResponse;
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 = "adScriptAncestry")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub ad_script_ancestry: Option<crate::network::types::AdAncestry>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetAdScriptAncestryResponse {
ad_script_ancestry: fields.ad_script_ancestry,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetAdScriptAncestry {
type Params = GetAdScriptAncestryParams;
type Response = GetAdScriptAncestryResponse;
const METHOD: &'static str = "Page.getAdScriptAncestry";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetAnnotatedPageContentParams {
#[serde(rename = "includeActionableInformation")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_actionable_information: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for GetAnnotatedPageContentParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetAnnotatedPageContentParams;
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 = "includeActionableInformation")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_actionable_information: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetAnnotatedPageContentParams {
include_actionable_information: fields.include_actionable_information,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetAnnotatedPageContent;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetAnnotatedPageContentResponse {
#[serde(rename = "content")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub content: String,
}
impl<'de> serde::Deserialize<'de> for GetAnnotatedPageContentResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetAnnotatedPageContentResponse;
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 = "content")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub content: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetAnnotatedPageContentResponse {
content: fields.content,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetAnnotatedPageContent {
type Params = GetAnnotatedPageContentParams;
type Response = GetAnnotatedPageContentResponse;
const METHOD: &'static str = "Page.getAnnotatedPageContent";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetAppIdParams {}
impl<'de> serde::Deserialize<'de> for GetAppIdParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetAppIdParams;
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(GetAppIdParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetAppId;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetAppIdResponse {
#[serde(rename = "appId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub app_id: Option<String>,
#[serde(rename = "recommendedId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub recommended_id: Option<String>,
}
impl<'de> serde::Deserialize<'de> for GetAppIdResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetAppIdResponse;
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 = "appId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub app_id: Option<String>,
#[serde(rename = "recommendedId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub recommended_id: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetAppIdResponse {
app_id: fields.app_id,
recommended_id: fields.recommended_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetAppId {
type Params = GetAppIdParams;
type Response = GetAppIdResponse;
const METHOD: &'static str = "Page.getAppId";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetAppManifestParams {
#[serde(rename = "manifestId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub manifest_id: Option<String>,
}
impl<'de> serde::Deserialize<'de> for GetAppManifestParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetAppManifestParams;
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 = "manifestId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub manifest_id: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetAppManifestParams {
manifest_id: fields.manifest_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetAppManifest;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetAppManifestResponse {
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "errors")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub errors: Vec<crate::page::types::AppManifestError>,
#[serde(rename = "data")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub data: Option<String>,
#[serde(rename = "parsed")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub parsed: Option<crate::page::types::AppManifestParsedProperties>,
#[serde(rename = "manifest")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest: crate::page::types::WebAppManifest,
}
impl<'de> serde::Deserialize<'de> for GetAppManifestResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetAppManifestResponse;
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,
#[serde(rename = "errors")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub errors: Vec<crate::page::types::AppManifestError>,
#[serde(rename = "data")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub data: Option<String>,
#[serde(rename = "parsed")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub parsed: Option<crate::page::types::AppManifestParsedProperties>,
#[serde(rename = "manifest")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest: crate::page::types::WebAppManifest,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetAppManifestResponse {
url: fields.url,
errors: fields.errors,
data: fields.data,
parsed: fields.parsed,
manifest: fields.manifest,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetAppManifest {
type Params = GetAppManifestParams;
type Response = GetAppManifestResponse;
const METHOD: &'static str = "Page.getAppManifest";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetFrameTreeParams {}
impl<'de> serde::Deserialize<'de> for GetFrameTreeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetFrameTreeParams;
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(GetFrameTreeParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetFrameTree;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetFrameTreeResponse {
#[serde(rename = "frameTree")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_tree: crate::page::types::FrameTree,
}
impl<'de> serde::Deserialize<'de> for GetFrameTreeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetFrameTreeResponse;
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 = "frameTree")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_tree: crate::page::types::FrameTree,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetFrameTreeResponse {
frame_tree: fields.frame_tree,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetFrameTree {
type Params = GetFrameTreeParams;
type Response = GetFrameTreeResponse;
const METHOD: &'static str = "Page.getFrameTree";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetInstallabilityErrorsParams {}
impl<'de> serde::Deserialize<'de> for GetInstallabilityErrorsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetInstallabilityErrorsParams;
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(GetInstallabilityErrorsParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetInstallabilityErrors;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetInstallabilityErrorsResponse {
#[serde(rename = "installabilityErrors")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub installability_errors: Vec<crate::page::types::InstallabilityError>,
}
impl<'de> serde::Deserialize<'de> for GetInstallabilityErrorsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetInstallabilityErrorsResponse;
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 = "installabilityErrors")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub installability_errors: Vec<crate::page::types::InstallabilityError>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetInstallabilityErrorsResponse {
installability_errors: fields.installability_errors,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetInstallabilityErrors {
type Params = GetInstallabilityErrorsParams;
type Response = GetInstallabilityErrorsResponse;
const METHOD: &'static str = "Page.getInstallabilityErrors";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetLayoutMetricsParams {}
impl<'de> serde::Deserialize<'de> for GetLayoutMetricsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetLayoutMetricsParams;
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(GetLayoutMetricsParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetLayoutMetrics;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetLayoutMetricsResponse {
#[serde(rename = "layoutViewport")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub layout_viewport: crate::page::types::LayoutViewport,
#[serde(rename = "visualViewport")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub visual_viewport: crate::page::types::VisualViewport,
#[serde(rename = "contentSize")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub content_size: crate::dom::types::Rect,
#[serde(rename = "cssLayoutViewport")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub css_layout_viewport: crate::page::types::LayoutViewport,
#[serde(rename = "cssVisualViewport")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub css_visual_viewport: crate::page::types::VisualViewport,
#[serde(rename = "cssContentSize")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub css_content_size: crate::dom::types::Rect,
}
impl<'de> serde::Deserialize<'de> for GetLayoutMetricsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetLayoutMetricsResponse;
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 = "layoutViewport")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub layout_viewport: crate::page::types::LayoutViewport,
#[serde(rename = "visualViewport")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub visual_viewport: crate::page::types::VisualViewport,
#[serde(rename = "contentSize")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub content_size: crate::dom::types::Rect,
#[serde(rename = "cssLayoutViewport")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub css_layout_viewport: crate::page::types::LayoutViewport,
#[serde(rename = "cssVisualViewport")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub css_visual_viewport: crate::page::types::VisualViewport,
#[serde(rename = "cssContentSize")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub css_content_size: crate::dom::types::Rect,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetLayoutMetricsResponse {
layout_viewport: fields.layout_viewport,
visual_viewport: fields.visual_viewport,
content_size: fields.content_size,
css_layout_viewport: fields.css_layout_viewport,
css_visual_viewport: fields.css_visual_viewport,
css_content_size: fields.css_content_size,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetLayoutMetrics {
type Params = GetLayoutMetricsParams;
type Response = GetLayoutMetricsResponse;
const METHOD: &'static str = "Page.getLayoutMetrics";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetManifestIconsParams {}
impl<'de> serde::Deserialize<'de> for GetManifestIconsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetManifestIconsParams;
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(GetManifestIconsParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetManifestIcons;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetManifestIconsResponse {
#[serde(rename = "primaryIcon")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub primary_icon: Option<String>,
}
impl<'de> serde::Deserialize<'de> for GetManifestIconsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetManifestIconsResponse;
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 = "primaryIcon")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub primary_icon: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetManifestIconsResponse {
primary_icon: fields.primary_icon,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetManifestIcons {
type Params = GetManifestIconsParams;
type Response = GetManifestIconsResponse;
const METHOD: &'static str = "Page.getManifestIcons";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetNavigationHistoryParams {}
impl<'de> serde::Deserialize<'de> for GetNavigationHistoryParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetNavigationHistoryParams;
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(GetNavigationHistoryParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetNavigationHistory;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetNavigationHistoryResponse {
#[serde(rename = "currentIndex")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub current_index: i64,
#[serde(rename = "entries")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub entries: Vec<crate::page::types::NavigationEntry>,
}
impl<'de> serde::Deserialize<'de> for GetNavigationHistoryResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetNavigationHistoryResponse;
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 = "currentIndex")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub current_index: i64,
#[serde(rename = "entries")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub entries: Vec<crate::page::types::NavigationEntry>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetNavigationHistoryResponse {
current_index: fields.current_index,
entries: fields.entries,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetNavigationHistory {
type Params = GetNavigationHistoryParams;
type Response = GetNavigationHistoryResponse;
const METHOD: &'static str = "Page.getNavigationHistory";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetOriginTrialsParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
impl<'de> serde::Deserialize<'de> for GetOriginTrialsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetOriginTrialsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetOriginTrialsParams {
frame_id: fields.frame_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetOriginTrials;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetOriginTrialsResponse {
#[serde(rename = "originTrials")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin_trials: Vec<crate::page::types::OriginTrial>,
}
impl<'de> serde::Deserialize<'de> for GetOriginTrialsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetOriginTrialsResponse;
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 = "originTrials")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin_trials: Vec<crate::page::types::OriginTrial>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetOriginTrialsResponse {
origin_trials: fields.origin_trials,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetOriginTrials {
type Params = GetOriginTrialsParams;
type Response = GetOriginTrialsResponse;
const METHOD: &'static str = "Page.getOriginTrials";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetPermissionsPolicyStateParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
impl<'de> serde::Deserialize<'de> for GetPermissionsPolicyStateParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetPermissionsPolicyStateParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetPermissionsPolicyStateParams {
frame_id: fields.frame_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetPermissionsPolicyState;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetPermissionsPolicyStateResponse {
#[serde(rename = "states")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub states: Vec<crate::page::types::PermissionsPolicyFeatureState>,
}
impl<'de> serde::Deserialize<'de> for GetPermissionsPolicyStateResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetPermissionsPolicyStateResponse;
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 = "states")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub states: Vec<crate::page::types::PermissionsPolicyFeatureState>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetPermissionsPolicyStateResponse {
states: fields.states,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetPermissionsPolicyState {
type Params = GetPermissionsPolicyStateParams;
type Response = GetPermissionsPolicyStateResponse;
const METHOD: &'static str = "Page.getPermissionsPolicyState";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetResourceContentParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
}
impl<'de> serde::Deserialize<'de> for GetResourceContentParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetResourceContentParams;
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 = "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(GetResourceContentParams {
frame_id: fields.frame_id,
url: fields.url,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetResourceContent;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetResourceContentResponse {
#[serde(rename = "content")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub content: String,
#[serde(rename = "base64Encoded")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub base64_encoded: bool,
}
impl<'de> serde::Deserialize<'de> for GetResourceContentResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetResourceContentResponse;
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 = "content")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub content: String,
#[serde(rename = "base64Encoded")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub base64_encoded: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetResourceContentResponse {
content: fields.content,
base64_encoded: fields.base64_encoded,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetResourceContent {
type Params = GetResourceContentParams;
type Response = GetResourceContentResponse;
const METHOD: &'static str = "Page.getResourceContent";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetResourceTreeParams {}
impl<'de> serde::Deserialize<'de> for GetResourceTreeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetResourceTreeParams;
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(GetResourceTreeParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetResourceTree;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetResourceTreeResponse {
#[serde(rename = "frameTree")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_tree: crate::page::types::FrameResourceTree,
}
impl<'de> serde::Deserialize<'de> for GetResourceTreeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetResourceTreeResponse;
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 = "frameTree")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_tree: crate::page::types::FrameResourceTree,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetResourceTreeResponse {
frame_tree: fields.frame_tree,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetResourceTree {
type Params = GetResourceTreeParams;
type Response = GetResourceTreeResponse;
const METHOD: &'static str = "Page.getResourceTree";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct HandleJavaScriptDialogParams {
#[serde(rename = "accept")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub accept: bool,
#[serde(rename = "promptText")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub prompt_text: Option<String>,
}
impl<'de> serde::Deserialize<'de> for HandleJavaScriptDialogParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = HandleJavaScriptDialogParams;
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 = "accept")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub accept: bool,
#[serde(rename = "promptText")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub prompt_text: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(HandleJavaScriptDialogParams {
accept: fields.accept,
prompt_text: fields.prompt_text,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct HandleJavaScriptDialog;
#[derive(Debug, Clone, serde::Serialize)]
pub struct HandleJavaScriptDialogResponse {}
impl<'de> serde::Deserialize<'de> for HandleJavaScriptDialogResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = HandleJavaScriptDialogResponse;
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(HandleJavaScriptDialogResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for HandleJavaScriptDialog {
type Params = HandleJavaScriptDialogParams;
type Response = HandleJavaScriptDialogResponse;
const METHOD: &'static str = "Page.handleJavaScriptDialog";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct NavigateParams {
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "referrer")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub referrer: Option<String>,
#[serde(rename = "transitionType")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub transition_type: Option<crate::page::types::TransitionType>,
#[serde(rename = "frameId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub frame_id: Option<crate::page::types::FrameId>,
#[serde(rename = "referrerPolicy")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub referrer_policy: Option<crate::page::types::ReferrerPolicy>,
}
impl<'de> serde::Deserialize<'de> for NavigateParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = NavigateParams;
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,
#[serde(rename = "referrer")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub referrer: Option<String>,
#[serde(rename = "transitionType")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub transition_type: Option<crate::page::types::TransitionType>,
#[serde(rename = "frameId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub frame_id: Option<crate::page::types::FrameId>,
#[serde(rename = "referrerPolicy")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub referrer_policy: Option<crate::page::types::ReferrerPolicy>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(NavigateParams {
url: fields.url,
referrer: fields.referrer,
transition_type: fields.transition_type,
frame_id: fields.frame_id,
referrer_policy: fields.referrer_policy,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Navigate;
#[derive(Debug, Clone, serde::Serialize)]
pub struct NavigateResponse {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "loaderId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub loader_id: Option<crate::network::types::LoaderId>,
#[serde(rename = "errorText")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub error_text: Option<String>,
#[serde(rename = "isDownload")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub is_download: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for NavigateResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = NavigateResponse;
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 = "loaderId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub loader_id: Option<crate::network::types::LoaderId>,
#[serde(rename = "errorText")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub error_text: Option<String>,
#[serde(rename = "isDownload")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub is_download: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(NavigateResponse {
frame_id: fields.frame_id,
loader_id: fields.loader_id,
error_text: fields.error_text,
is_download: fields.is_download,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Navigate {
type Params = NavigateParams;
type Response = NavigateResponse;
const METHOD: &'static str = "Page.navigate";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct NavigateToHistoryEntryParams {
#[serde(rename = "entryId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub entry_id: i64,
}
impl<'de> serde::Deserialize<'de> for NavigateToHistoryEntryParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = NavigateToHistoryEntryParams;
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 = "entryId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub entry_id: i64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(NavigateToHistoryEntryParams {
entry_id: fields.entry_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct NavigateToHistoryEntry;
#[derive(Debug, Clone, serde::Serialize)]
pub struct NavigateToHistoryEntryResponse {}
impl<'de> serde::Deserialize<'de> for NavigateToHistoryEntryResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = NavigateToHistoryEntryResponse;
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(NavigateToHistoryEntryResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for NavigateToHistoryEntry {
type Params = NavigateToHistoryEntryParams;
type Response = NavigateToHistoryEntryResponse;
const METHOD: &'static str = "Page.navigateToHistoryEntry";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum PrintToPdfParamsTransferMode {
ReturnAsBase64,
ReturnAsStream,
Unknown(String),
}
impl PrintToPdfParamsTransferMode {
pub fn as_str(&self) -> &str {
match self {
Self::ReturnAsBase64 => "ReturnAsBase64",
Self::ReturnAsStream => "ReturnAsStream",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for PrintToPdfParamsTransferMode {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for PrintToPdfParamsTransferMode {
fn from(value: String) -> Self {
match value.as_str() {
"ReturnAsBase64" => PrintToPdfParamsTransferMode::ReturnAsBase64,
"ReturnAsStream" => PrintToPdfParamsTransferMode::ReturnAsStream,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for PrintToPdfParamsTransferMode {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for PrintToPdfParamsTransferMode {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PrintToPdfParamsTransferMode;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议字符串枚举")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
Ok(match v {
"ReturnAsBase64" => PrintToPdfParamsTransferMode::ReturnAsBase64,
"ReturnAsStream" => PrintToPdfParamsTransferMode::ReturnAsStream,
_ => PrintToPdfParamsTransferMode::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(PrintToPdfParamsTransferMode::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct PrintToPdfParams {
#[serde(rename = "landscape")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub landscape: Option<bool>,
#[serde(rename = "displayHeaderFooter")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub display_header_footer: Option<bool>,
#[serde(rename = "printBackground")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub print_background: Option<bool>,
#[serde(rename = "scale")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub scale: Option<ydp_core::FiniteF64>,
#[serde(rename = "paperWidth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub paper_width: Option<ydp_core::FiniteF64>,
#[serde(rename = "paperHeight")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub paper_height: Option<ydp_core::FiniteF64>,
#[serde(rename = "marginTop")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub margin_top: Option<ydp_core::FiniteF64>,
#[serde(rename = "marginBottom")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub margin_bottom: Option<ydp_core::FiniteF64>,
#[serde(rename = "marginLeft")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub margin_left: Option<ydp_core::FiniteF64>,
#[serde(rename = "marginRight")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub margin_right: Option<ydp_core::FiniteF64>,
#[serde(rename = "pageRanges")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub page_ranges: Option<String>,
#[serde(rename = "headerTemplate")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub header_template: Option<String>,
#[serde(rename = "footerTemplate")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub footer_template: Option<String>,
#[serde(rename = "preferCSSPageSize")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub prefer_css_page_size: Option<bool>,
#[serde(rename = "transferMode")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub transfer_mode: Option<PrintToPdfParamsTransferMode>,
#[serde(rename = "generateTaggedPDF")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub generate_tagged_pdf: Option<bool>,
#[serde(rename = "generateDocumentOutline")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub generate_document_outline: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for PrintToPdfParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PrintToPdfParams;
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 = "landscape")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub landscape: Option<bool>,
#[serde(rename = "displayHeaderFooter")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub display_header_footer: Option<bool>,
#[serde(rename = "printBackground")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub print_background: Option<bool>,
#[serde(rename = "scale")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub scale: Option<ydp_core::FiniteF64>,
#[serde(rename = "paperWidth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub paper_width: Option<ydp_core::FiniteF64>,
#[serde(rename = "paperHeight")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub paper_height: Option<ydp_core::FiniteF64>,
#[serde(rename = "marginTop")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub margin_top: Option<ydp_core::FiniteF64>,
#[serde(rename = "marginBottom")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub margin_bottom: Option<ydp_core::FiniteF64>,
#[serde(rename = "marginLeft")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub margin_left: Option<ydp_core::FiniteF64>,
#[serde(rename = "marginRight")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub margin_right: Option<ydp_core::FiniteF64>,
#[serde(rename = "pageRanges")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub page_ranges: Option<String>,
#[serde(rename = "headerTemplate")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub header_template: Option<String>,
#[serde(rename = "footerTemplate")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub footer_template: Option<String>,
#[serde(rename = "preferCSSPageSize")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub prefer_css_page_size: Option<bool>,
#[serde(rename = "transferMode")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub transfer_mode: Option<PrintToPdfParamsTransferMode>,
#[serde(rename = "generateTaggedPDF")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub generate_tagged_pdf: Option<bool>,
#[serde(rename = "generateDocumentOutline")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub generate_document_outline: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PrintToPdfParams {
landscape: fields.landscape,
display_header_footer: fields.display_header_footer,
print_background: fields.print_background,
scale: fields.scale,
paper_width: fields.paper_width,
paper_height: fields.paper_height,
margin_top: fields.margin_top,
margin_bottom: fields.margin_bottom,
margin_left: fields.margin_left,
margin_right: fields.margin_right,
page_ranges: fields.page_ranges,
header_template: fields.header_template,
footer_template: fields.footer_template,
prefer_css_page_size: fields.prefer_css_page_size,
transfer_mode: fields.transfer_mode,
generate_tagged_pdf: fields.generate_tagged_pdf,
generate_document_outline: fields.generate_document_outline,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct PrintToPdf;
#[derive(Debug, Clone, serde::Serialize)]
pub struct PrintToPdfResponse {
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
#[serde(rename = "stream")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub stream: Option<crate::io::types::StreamHandle>,
}
impl<'de> serde::Deserialize<'de> for PrintToPdfResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PrintToPdfResponse;
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 = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
#[serde(rename = "stream")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub stream: Option<crate::io::types::StreamHandle>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PrintToPdfResponse {
data: fields.data,
stream: fields.stream,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for PrintToPdf {
type Params = PrintToPdfParams;
type Response = PrintToPdfResponse;
const METHOD: &'static str = "Page.printToPDF";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ProduceCompilationCacheParams {
#[serde(rename = "scripts")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub scripts: Vec<crate::page::types::CompilationCacheParams>,
}
impl<'de> serde::Deserialize<'de> for ProduceCompilationCacheParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ProduceCompilationCacheParams;
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 = "scripts")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub scripts: Vec<crate::page::types::CompilationCacheParams>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ProduceCompilationCacheParams {
scripts: fields.scripts,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ProduceCompilationCache;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ProduceCompilationCacheResponse {}
impl<'de> serde::Deserialize<'de> for ProduceCompilationCacheResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ProduceCompilationCacheResponse;
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(ProduceCompilationCacheResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ProduceCompilationCache {
type Params = ProduceCompilationCacheParams;
type Response = ProduceCompilationCacheResponse;
const METHOD: &'static str = "Page.produceCompilationCache";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct ReloadParams {
#[serde(rename = "ignoreCache")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub ignore_cache: Option<bool>,
#[serde(rename = "scriptToEvaluateOnLoad")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub script_to_evaluate_on_load: Option<String>,
#[serde(rename = "loaderId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub loader_id: Option<crate::network::types::LoaderId>,
}
impl<'de> serde::Deserialize<'de> for ReloadParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ReloadParams;
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 = "ignoreCache")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub ignore_cache: Option<bool>,
#[serde(rename = "scriptToEvaluateOnLoad")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub script_to_evaluate_on_load: Option<String>,
#[serde(rename = "loaderId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub loader_id: Option<crate::network::types::LoaderId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ReloadParams {
ignore_cache: fields.ignore_cache,
script_to_evaluate_on_load: fields.script_to_evaluate_on_load,
loader_id: fields.loader_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Reload;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ReloadResponse {}
impl<'de> serde::Deserialize<'de> for ReloadResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ReloadResponse;
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(ReloadResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Reload {
type Params = ReloadParams;
type Response = ReloadResponse;
const METHOD: &'static str = "Page.reload";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveScriptToEvaluateOnLoadParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::page::types::ScriptIdentifier,
}
impl<'de> serde::Deserialize<'de> for RemoveScriptToEvaluateOnLoadParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveScriptToEvaluateOnLoadParams;
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 = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::page::types::ScriptIdentifier,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RemoveScriptToEvaluateOnLoadParams {
identifier: fields.identifier,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RemoveScriptToEvaluateOnLoad;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveScriptToEvaluateOnLoadResponse {}
impl<'de> serde::Deserialize<'de> for RemoveScriptToEvaluateOnLoadResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveScriptToEvaluateOnLoadResponse;
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(RemoveScriptToEvaluateOnLoadResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RemoveScriptToEvaluateOnLoad {
type Params = RemoveScriptToEvaluateOnLoadParams;
type Response = RemoveScriptToEvaluateOnLoadResponse;
const METHOD: &'static str = "Page.removeScriptToEvaluateOnLoad";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveScriptToEvaluateOnNewDocumentParams {
#[serde(rename = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::page::types::ScriptIdentifier,
}
impl<'de> serde::Deserialize<'de> for RemoveScriptToEvaluateOnNewDocumentParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveScriptToEvaluateOnNewDocumentParams;
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 = "identifier")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub identifier: crate::page::types::ScriptIdentifier,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RemoveScriptToEvaluateOnNewDocumentParams {
identifier: fields.identifier,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RemoveScriptToEvaluateOnNewDocument;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveScriptToEvaluateOnNewDocumentResponse {}
impl<'de> serde::Deserialize<'de> for RemoveScriptToEvaluateOnNewDocumentResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveScriptToEvaluateOnNewDocumentResponse;
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(RemoveScriptToEvaluateOnNewDocumentResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RemoveScriptToEvaluateOnNewDocument {
type Params = RemoveScriptToEvaluateOnNewDocumentParams;
type Response = RemoveScriptToEvaluateOnNewDocumentResponse;
const METHOD: &'static str = "Page.removeScriptToEvaluateOnNewDocument";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct ResetNavigationHistoryParams {}
impl<'de> serde::Deserialize<'de> for ResetNavigationHistoryParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResetNavigationHistoryParams;
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(ResetNavigationHistoryParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ResetNavigationHistory;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ResetNavigationHistoryResponse {}
impl<'de> serde::Deserialize<'de> for ResetNavigationHistoryResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResetNavigationHistoryResponse;
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(ResetNavigationHistoryResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ResetNavigationHistory {
type Params = ResetNavigationHistoryParams;
type Response = ResetNavigationHistoryResponse;
const METHOD: &'static str = "Page.resetNavigationHistory";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ScreencastFrameAckParams {
#[serde(rename = "sessionId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub session_id: i64,
}
impl<'de> serde::Deserialize<'de> for ScreencastFrameAckParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ScreencastFrameAckParams;
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 = "sessionId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub session_id: i64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ScreencastFrameAckParams {
session_id: fields.session_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ScreencastFrameAck;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ScreencastFrameAckResponse {}
impl<'de> serde::Deserialize<'de> for ScreencastFrameAckResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ScreencastFrameAckResponse;
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(ScreencastFrameAckResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ScreencastFrameAck {
type Params = ScreencastFrameAckParams;
type Response = ScreencastFrameAckResponse;
const METHOD: &'static str = "Page.screencastFrameAck";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SearchInResourceParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "query")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub query: String,
#[serde(rename = "caseSensitive")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub case_sensitive: Option<bool>,
#[serde(rename = "isRegex")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub is_regex: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for SearchInResourceParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SearchInResourceParams;
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 = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
#[serde(rename = "query")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub query: String,
#[serde(rename = "caseSensitive")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub case_sensitive: Option<bool>,
#[serde(rename = "isRegex")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub is_regex: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SearchInResourceParams {
frame_id: fields.frame_id,
url: fields.url,
query: fields.query,
case_sensitive: fields.case_sensitive,
is_regex: fields.is_regex,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SearchInResource;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SearchInResourceResponse {
#[serde(rename = "result")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub result: Vec<crate::debugger::types::SearchMatch>,
}
impl<'de> serde::Deserialize<'de> for SearchInResourceResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SearchInResourceResponse;
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: Vec<crate::debugger::types::SearchMatch>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SearchInResourceResponse {
result: fields.result,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SearchInResource {
type Params = SearchInResourceParams;
type Response = SearchInResourceResponse;
const METHOD: &'static str = "Page.searchInResource";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetAdBlockingEnabledParams {
#[serde(rename = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
}
impl<'de> serde::Deserialize<'de> for SetAdBlockingEnabledParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetAdBlockingEnabledParams;
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 = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetAdBlockingEnabledParams {
enabled: fields.enabled,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetAdBlockingEnabled;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetAdBlockingEnabledResponse {}
impl<'de> serde::Deserialize<'de> for SetAdBlockingEnabledResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetAdBlockingEnabledResponse;
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(SetAdBlockingEnabledResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetAdBlockingEnabled {
type Params = SetAdBlockingEnabledParams;
type Response = SetAdBlockingEnabledResponse;
const METHOD: &'static str = "Page.setAdBlockingEnabled";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetBypassCspParams {
#[serde(rename = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
}
impl<'de> serde::Deserialize<'de> for SetBypassCspParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetBypassCspParams;
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 = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetBypassCspParams {
enabled: fields.enabled,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetBypassCsp;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetBypassCspResponse {}
impl<'de> serde::Deserialize<'de> for SetBypassCspResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetBypassCspResponse;
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(SetBypassCspResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetBypassCsp {
type Params = SetBypassCspParams;
type Response = SetBypassCspResponse;
const METHOD: &'static str = "Page.setBypassCSP";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDeviceMetricsOverrideParams {
#[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 = "deviceScaleFactor")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub device_scale_factor: ydp_core::FiniteF64,
#[serde(rename = "mobile")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub mobile: bool,
#[serde(rename = "scale")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub scale: Option<ydp_core::FiniteF64>,
#[serde(rename = "screenWidth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub screen_width: Option<i64>,
#[serde(rename = "screenHeight")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub screen_height: Option<i64>,
#[serde(rename = "positionX")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub position_x: Option<i64>,
#[serde(rename = "positionY")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub position_y: Option<i64>,
#[serde(rename = "dontSetVisibleSize")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub dont_set_visible_size: Option<bool>,
#[serde(rename = "screenOrientation")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub screen_orientation: Option<crate::emulation::types::ScreenOrientation>,
#[serde(rename = "viewport")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub viewport: Option<crate::page::types::Viewport>,
}
impl<'de> serde::Deserialize<'de> for SetDeviceMetricsOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDeviceMetricsOverrideParams;
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 = "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 = "deviceScaleFactor")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub device_scale_factor: ydp_core::FiniteF64,
#[serde(rename = "mobile")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub mobile: bool,
#[serde(rename = "scale")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub scale: Option<ydp_core::FiniteF64>,
#[serde(rename = "screenWidth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub screen_width: Option<i64>,
#[serde(rename = "screenHeight")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub screen_height: Option<i64>,
#[serde(rename = "positionX")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub position_x: Option<i64>,
#[serde(rename = "positionY")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub position_y: Option<i64>,
#[serde(rename = "dontSetVisibleSize")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub dont_set_visible_size: Option<bool>,
#[serde(rename = "screenOrientation")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub screen_orientation: Option<crate::emulation::types::ScreenOrientation>,
#[serde(rename = "viewport")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub viewport: Option<crate::page::types::Viewport>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetDeviceMetricsOverrideParams {
width: fields.width,
height: fields.height,
device_scale_factor: fields.device_scale_factor,
mobile: fields.mobile,
scale: fields.scale,
screen_width: fields.screen_width,
screen_height: fields.screen_height,
position_x: fields.position_x,
position_y: fields.position_y,
dont_set_visible_size: fields.dont_set_visible_size,
screen_orientation: fields.screen_orientation,
viewport: fields.viewport,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetDeviceMetricsOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDeviceMetricsOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetDeviceMetricsOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDeviceMetricsOverrideResponse;
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(SetDeviceMetricsOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetDeviceMetricsOverride {
type Params = SetDeviceMetricsOverrideParams;
type Response = SetDeviceMetricsOverrideResponse;
const METHOD: &'static str = "Page.setDeviceMetricsOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDeviceOrientationOverrideParams {
#[serde(rename = "alpha")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub alpha: ydp_core::FiniteF64,
#[serde(rename = "beta")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub beta: ydp_core::FiniteF64,
#[serde(rename = "gamma")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub gamma: ydp_core::FiniteF64,
}
impl<'de> serde::Deserialize<'de> for SetDeviceOrientationOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDeviceOrientationOverrideParams;
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 = "alpha")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub alpha: ydp_core::FiniteF64,
#[serde(rename = "beta")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub beta: ydp_core::FiniteF64,
#[serde(rename = "gamma")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub gamma: ydp_core::FiniteF64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetDeviceOrientationOverrideParams {
alpha: fields.alpha,
beta: fields.beta,
gamma: fields.gamma,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetDeviceOrientationOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDeviceOrientationOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetDeviceOrientationOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDeviceOrientationOverrideResponse;
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(SetDeviceOrientationOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetDeviceOrientationOverride {
type Params = SetDeviceOrientationOverrideParams;
type Response = SetDeviceOrientationOverrideResponse;
const METHOD: &'static str = "Page.setDeviceOrientationOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDocumentContentParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
#[serde(rename = "html")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub html: String,
}
impl<'de> serde::Deserialize<'de> for SetDocumentContentParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDocumentContentParams;
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 = "html")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub html: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetDocumentContentParams {
frame_id: fields.frame_id,
html: fields.html,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetDocumentContent;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDocumentContentResponse {}
impl<'de> serde::Deserialize<'de> for SetDocumentContentResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDocumentContentResponse;
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(SetDocumentContentResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetDocumentContent {
type Params = SetDocumentContentParams;
type Response = SetDocumentContentResponse;
const METHOD: &'static str = "Page.setDocumentContent";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum SetDownloadBehaviorParamsBehavior {
Deny,
Allow,
Default,
Unknown(String),
}
impl SetDownloadBehaviorParamsBehavior {
pub fn as_str(&self) -> &str {
match self {
Self::Deny => "deny",
Self::Allow => "allow",
Self::Default => "default",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for SetDownloadBehaviorParamsBehavior {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for SetDownloadBehaviorParamsBehavior {
fn from(value: String) -> Self {
match value.as_str() {
"deny" => SetDownloadBehaviorParamsBehavior::Deny,
"allow" => SetDownloadBehaviorParamsBehavior::Allow,
"default" => SetDownloadBehaviorParamsBehavior::Default,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for SetDownloadBehaviorParamsBehavior {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for SetDownloadBehaviorParamsBehavior {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDownloadBehaviorParamsBehavior;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议字符串枚举")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
Ok(match v {
"deny" => SetDownloadBehaviorParamsBehavior::Deny,
"allow" => SetDownloadBehaviorParamsBehavior::Allow,
"default" => SetDownloadBehaviorParamsBehavior::Default,
_ => SetDownloadBehaviorParamsBehavior::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(SetDownloadBehaviorParamsBehavior::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDownloadBehaviorParams {
#[serde(rename = "behavior")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub behavior: SetDownloadBehaviorParamsBehavior,
#[serde(rename = "downloadPath")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub download_path: Option<String>,
}
impl<'de> serde::Deserialize<'de> for SetDownloadBehaviorParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDownloadBehaviorParams;
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 = "behavior")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub behavior: SetDownloadBehaviorParamsBehavior,
#[serde(rename = "downloadPath")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub download_path: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetDownloadBehaviorParams {
behavior: fields.behavior,
download_path: fields.download_path,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetDownloadBehavior;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDownloadBehaviorResponse {}
impl<'de> serde::Deserialize<'de> for SetDownloadBehaviorResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDownloadBehaviorResponse;
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(SetDownloadBehaviorResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetDownloadBehavior {
type Params = SetDownloadBehaviorParams;
type Response = SetDownloadBehaviorResponse;
const METHOD: &'static str = "Page.setDownloadBehavior";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetFontFamiliesParams {
#[serde(rename = "fontFamilies")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub font_families: crate::page::types::FontFamilies,
#[serde(rename = "forScripts")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub for_scripts: Option<Vec<crate::page::types::ScriptFontFamilies>>,
}
impl<'de> serde::Deserialize<'de> for SetFontFamiliesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetFontFamiliesParams;
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 = "fontFamilies")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub font_families: crate::page::types::FontFamilies,
#[serde(rename = "forScripts")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub for_scripts: Option<Vec<crate::page::types::ScriptFontFamilies>>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetFontFamiliesParams {
font_families: fields.font_families,
for_scripts: fields.for_scripts,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetFontFamilies;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetFontFamiliesResponse {}
impl<'de> serde::Deserialize<'de> for SetFontFamiliesResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetFontFamiliesResponse;
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(SetFontFamiliesResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetFontFamilies {
type Params = SetFontFamiliesParams;
type Response = SetFontFamiliesResponse;
const METHOD: &'static str = "Page.setFontFamilies";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetFontSizesParams {
#[serde(rename = "fontSizes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub font_sizes: crate::page::types::FontSizes,
}
impl<'de> serde::Deserialize<'de> for SetFontSizesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetFontSizesParams;
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 = "fontSizes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub font_sizes: crate::page::types::FontSizes,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetFontSizesParams {
font_sizes: fields.font_sizes,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetFontSizes;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetFontSizesResponse {}
impl<'de> serde::Deserialize<'de> for SetFontSizesResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetFontSizesResponse;
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(SetFontSizesResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetFontSizes {
type Params = SetFontSizesParams;
type Response = SetFontSizesResponse;
const METHOD: &'static str = "Page.setFontSizes";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct SetGeolocationOverrideParams {
#[serde(rename = "latitude")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub latitude: Option<ydp_core::FiniteF64>,
#[serde(rename = "longitude")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub longitude: Option<ydp_core::FiniteF64>,
#[serde(rename = "accuracy")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub accuracy: Option<ydp_core::FiniteF64>,
}
impl<'de> serde::Deserialize<'de> for SetGeolocationOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetGeolocationOverrideParams;
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 = "latitude")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub latitude: Option<ydp_core::FiniteF64>,
#[serde(rename = "longitude")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub longitude: Option<ydp_core::FiniteF64>,
#[serde(rename = "accuracy")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub accuracy: Option<ydp_core::FiniteF64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetGeolocationOverrideParams {
latitude: fields.latitude,
longitude: fields.longitude,
accuracy: fields.accuracy,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetGeolocationOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetGeolocationOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetGeolocationOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetGeolocationOverrideResponse;
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(SetGeolocationOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetGeolocationOverride {
type Params = SetGeolocationOverrideParams;
type Response = SetGeolocationOverrideResponse;
const METHOD: &'static str = "Page.setGeolocationOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetInterceptFileChooserDialogParams {
#[serde(rename = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
#[serde(rename = "cancel")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub cancel: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for SetInterceptFileChooserDialogParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetInterceptFileChooserDialogParams;
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 = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
#[serde(rename = "cancel")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub cancel: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetInterceptFileChooserDialogParams {
enabled: fields.enabled,
cancel: fields.cancel,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetInterceptFileChooserDialog;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetInterceptFileChooserDialogResponse {}
impl<'de> serde::Deserialize<'de> for SetInterceptFileChooserDialogResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetInterceptFileChooserDialogResponse;
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(SetInterceptFileChooserDialogResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetInterceptFileChooserDialog {
type Params = SetInterceptFileChooserDialogParams;
type Response = SetInterceptFileChooserDialogResponse;
const METHOD: &'static str = "Page.setInterceptFileChooserDialog";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetLifecycleEventsEnabledParams {
#[serde(rename = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
}
impl<'de> serde::Deserialize<'de> for SetLifecycleEventsEnabledParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetLifecycleEventsEnabledParams;
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 = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetLifecycleEventsEnabledParams {
enabled: fields.enabled,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetLifecycleEventsEnabled;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetLifecycleEventsEnabledResponse {}
impl<'de> serde::Deserialize<'de> for SetLifecycleEventsEnabledResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetLifecycleEventsEnabledResponse;
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(SetLifecycleEventsEnabledResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetLifecycleEventsEnabled {
type Params = SetLifecycleEventsEnabledParams;
type Response = SetLifecycleEventsEnabledResponse;
const METHOD: &'static str = "Page.setLifecycleEventsEnabled";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPrerenderingAllowedParams {
#[serde(rename = "isAllowed")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub is_allowed: bool,
}
impl<'de> serde::Deserialize<'de> for SetPrerenderingAllowedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPrerenderingAllowedParams;
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 = "isAllowed")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub is_allowed: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetPrerenderingAllowedParams {
is_allowed: fields.is_allowed,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetPrerenderingAllowed;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPrerenderingAllowedResponse {}
impl<'de> serde::Deserialize<'de> for SetPrerenderingAllowedResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPrerenderingAllowedResponse;
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(SetPrerenderingAllowedResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetPrerenderingAllowed {
type Params = SetPrerenderingAllowedParams;
type Response = SetPrerenderingAllowedResponse;
const METHOD: &'static str = "Page.setPrerenderingAllowed";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum SetRphRegistrationModeParamsMode {
None,
AutoAccept,
AutoReject,
Unknown(String),
}
impl SetRphRegistrationModeParamsMode {
pub fn as_str(&self) -> &str {
match self {
Self::None => "none",
Self::AutoAccept => "autoAccept",
Self::AutoReject => "autoReject",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for SetRphRegistrationModeParamsMode {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for SetRphRegistrationModeParamsMode {
fn from(value: String) -> Self {
match value.as_str() {
"none" => SetRphRegistrationModeParamsMode::None,
"autoAccept" => SetRphRegistrationModeParamsMode::AutoAccept,
"autoReject" => SetRphRegistrationModeParamsMode::AutoReject,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for SetRphRegistrationModeParamsMode {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for SetRphRegistrationModeParamsMode {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetRphRegistrationModeParamsMode;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议字符串枚举")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
Ok(match v {
"none" => SetRphRegistrationModeParamsMode::None,
"autoAccept" => SetRphRegistrationModeParamsMode::AutoAccept,
"autoReject" => SetRphRegistrationModeParamsMode::AutoReject,
_ => SetRphRegistrationModeParamsMode::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(SetRphRegistrationModeParamsMode::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetRphRegistrationModeParams {
#[serde(rename = "mode")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub mode: SetRphRegistrationModeParamsMode,
}
impl<'de> serde::Deserialize<'de> for SetRphRegistrationModeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetRphRegistrationModeParams;
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: SetRphRegistrationModeParamsMode,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetRphRegistrationModeParams { mode: fields.mode })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetRphRegistrationMode;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetRphRegistrationModeResponse {}
impl<'de> serde::Deserialize<'de> for SetRphRegistrationModeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetRphRegistrationModeResponse;
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(SetRphRegistrationModeResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetRphRegistrationMode {
type Params = SetRphRegistrationModeParams;
type Response = SetRphRegistrationModeResponse;
const METHOD: &'static str = "Page.setRPHRegistrationMode";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum SetSpcTransactionModeParamsMode {
None,
AutoAccept,
AutoChooseToAuthAnotherWay,
AutoReject,
AutoOptOut,
Unknown(String),
}
impl SetSpcTransactionModeParamsMode {
pub fn as_str(&self) -> &str {
match self {
Self::None => "none",
Self::AutoAccept => "autoAccept",
Self::AutoChooseToAuthAnotherWay => "autoChooseToAuthAnotherWay",
Self::AutoReject => "autoReject",
Self::AutoOptOut => "autoOptOut",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for SetSpcTransactionModeParamsMode {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for SetSpcTransactionModeParamsMode {
fn from(value: String) -> Self {
match value.as_str() {
"none" => SetSpcTransactionModeParamsMode::None,
"autoAccept" => SetSpcTransactionModeParamsMode::AutoAccept,
"autoChooseToAuthAnotherWay" => {
SetSpcTransactionModeParamsMode::AutoChooseToAuthAnotherWay
}
"autoReject" => SetSpcTransactionModeParamsMode::AutoReject,
"autoOptOut" => SetSpcTransactionModeParamsMode::AutoOptOut,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for SetSpcTransactionModeParamsMode {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for SetSpcTransactionModeParamsMode {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetSpcTransactionModeParamsMode;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议字符串枚举")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
Ok(match v {
"none" => SetSpcTransactionModeParamsMode::None,
"autoAccept" => SetSpcTransactionModeParamsMode::AutoAccept,
"autoChooseToAuthAnotherWay" => {
SetSpcTransactionModeParamsMode::AutoChooseToAuthAnotherWay
}
"autoReject" => SetSpcTransactionModeParamsMode::AutoReject,
"autoOptOut" => SetSpcTransactionModeParamsMode::AutoOptOut,
_ => SetSpcTransactionModeParamsMode::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(SetSpcTransactionModeParamsMode::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetSpcTransactionModeParams {
#[serde(rename = "mode")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub mode: SetSpcTransactionModeParamsMode,
}
impl<'de> serde::Deserialize<'de> for SetSpcTransactionModeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetSpcTransactionModeParams;
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: SetSpcTransactionModeParamsMode,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetSpcTransactionModeParams { mode: fields.mode })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetSpcTransactionMode;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetSpcTransactionModeResponse {}
impl<'de> serde::Deserialize<'de> for SetSpcTransactionModeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetSpcTransactionModeResponse;
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(SetSpcTransactionModeResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetSpcTransactionMode {
type Params = SetSpcTransactionModeParams;
type Response = SetSpcTransactionModeResponse;
const METHOD: &'static str = "Page.setSPCTransactionMode";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum SetTouchEmulationEnabledParamsConfiguration {
Mobile,
Desktop,
Unknown(String),
}
impl SetTouchEmulationEnabledParamsConfiguration {
pub fn as_str(&self) -> &str {
match self {
Self::Mobile => "mobile",
Self::Desktop => "desktop",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for SetTouchEmulationEnabledParamsConfiguration {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for SetTouchEmulationEnabledParamsConfiguration {
fn from(value: String) -> Self {
match value.as_str() {
"mobile" => SetTouchEmulationEnabledParamsConfiguration::Mobile,
"desktop" => SetTouchEmulationEnabledParamsConfiguration::Desktop,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for SetTouchEmulationEnabledParamsConfiguration {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for SetTouchEmulationEnabledParamsConfiguration {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetTouchEmulationEnabledParamsConfiguration;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议字符串枚举")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
Ok(match v {
"mobile" => SetTouchEmulationEnabledParamsConfiguration::Mobile,
"desktop" => SetTouchEmulationEnabledParamsConfiguration::Desktop,
_ => SetTouchEmulationEnabledParamsConfiguration::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(SetTouchEmulationEnabledParamsConfiguration::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetTouchEmulationEnabledParams {
#[serde(rename = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
#[serde(rename = "configuration")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub configuration: Option<SetTouchEmulationEnabledParamsConfiguration>,
}
impl<'de> serde::Deserialize<'de> for SetTouchEmulationEnabledParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetTouchEmulationEnabledParams;
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 = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
#[serde(rename = "configuration")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub configuration: Option<SetTouchEmulationEnabledParamsConfiguration>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetTouchEmulationEnabledParams {
enabled: fields.enabled,
configuration: fields.configuration,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetTouchEmulationEnabled;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetTouchEmulationEnabledResponse {}
impl<'de> serde::Deserialize<'de> for SetTouchEmulationEnabledResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetTouchEmulationEnabledResponse;
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(SetTouchEmulationEnabledResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetTouchEmulationEnabled {
type Params = SetTouchEmulationEnabledParams;
type Response = SetTouchEmulationEnabledResponse;
const METHOD: &'static str = "Page.setTouchEmulationEnabled";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum SetWebLifecycleStateParamsState {
Frozen,
Active,
Unknown(String),
}
impl SetWebLifecycleStateParamsState {
pub fn as_str(&self) -> &str {
match self {
Self::Frozen => "frozen",
Self::Active => "active",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for SetWebLifecycleStateParamsState {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for SetWebLifecycleStateParamsState {
fn from(value: String) -> Self {
match value.as_str() {
"frozen" => SetWebLifecycleStateParamsState::Frozen,
"active" => SetWebLifecycleStateParamsState::Active,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for SetWebLifecycleStateParamsState {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for SetWebLifecycleStateParamsState {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetWebLifecycleStateParamsState;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议字符串枚举")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
Ok(match v {
"frozen" => SetWebLifecycleStateParamsState::Frozen,
"active" => SetWebLifecycleStateParamsState::Active,
_ => SetWebLifecycleStateParamsState::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(SetWebLifecycleStateParamsState::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetWebLifecycleStateParams {
#[serde(rename = "state")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub state: SetWebLifecycleStateParamsState,
}
impl<'de> serde::Deserialize<'de> for SetWebLifecycleStateParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetWebLifecycleStateParams;
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 = "state")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub state: SetWebLifecycleStateParamsState,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetWebLifecycleStateParams {
state: fields.state,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetWebLifecycleState;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetWebLifecycleStateResponse {}
impl<'de> serde::Deserialize<'de> for SetWebLifecycleStateResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetWebLifecycleStateResponse;
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(SetWebLifecycleStateResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetWebLifecycleState {
type Params = SetWebLifecycleStateParams;
type Response = SetWebLifecycleStateResponse;
const METHOD: &'static str = "Page.setWebLifecycleState";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct StartScreenRecordingParams {
#[serde(rename = "audio")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub audio: Option<bool>,
#[serde(rename = "maxWidth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub max_width: Option<i64>,
#[serde(rename = "maxHeight")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub max_height: Option<i64>,
#[serde(rename = "frameRate")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub frame_rate: Option<i64>,
}
impl<'de> serde::Deserialize<'de> for StartScreenRecordingParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StartScreenRecordingParams;
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 = "audio")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub audio: Option<bool>,
#[serde(rename = "maxWidth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub max_width: Option<i64>,
#[serde(rename = "maxHeight")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub max_height: Option<i64>,
#[serde(rename = "frameRate")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub frame_rate: Option<i64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(StartScreenRecordingParams {
audio: fields.audio,
max_width: fields.max_width,
max_height: fields.max_height,
frame_rate: fields.frame_rate,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct StartScreenRecording;
#[derive(Debug, Clone, serde::Serialize)]
pub struct StartScreenRecordingResponse {
#[serde(rename = "stream")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub stream: crate::io::types::StreamHandle,
}
impl<'de> serde::Deserialize<'de> for StartScreenRecordingResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StartScreenRecordingResponse;
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 = "stream")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub stream: crate::io::types::StreamHandle,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(StartScreenRecordingResponse {
stream: fields.stream,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for StartScreenRecording {
type Params = StartScreenRecordingParams;
type Response = StartScreenRecordingResponse;
const METHOD: &'static str = "Page.startScreenRecording";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum StartScreencastParamsFormat {
Jpeg,
Png,
Unknown(String),
}
impl StartScreencastParamsFormat {
pub fn as_str(&self) -> &str {
match self {
Self::Jpeg => "jpeg",
Self::Png => "png",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for StartScreencastParamsFormat {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for StartScreencastParamsFormat {
fn from(value: String) -> Self {
match value.as_str() {
"jpeg" => StartScreencastParamsFormat::Jpeg,
"png" => StartScreencastParamsFormat::Png,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for StartScreencastParamsFormat {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for StartScreencastParamsFormat {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StartScreencastParamsFormat;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议字符串枚举")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
Ok(match v {
"jpeg" => StartScreencastParamsFormat::Jpeg,
"png" => StartScreencastParamsFormat::Png,
_ => StartScreencastParamsFormat::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(StartScreencastParamsFormat::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct StartScreencastParams {
#[serde(rename = "format")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub format: Option<StartScreencastParamsFormat>,
#[serde(rename = "quality")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub quality: Option<i64>,
#[serde(rename = "maxWidth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub max_width: Option<i64>,
#[serde(rename = "maxHeight")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub max_height: Option<i64>,
#[serde(rename = "everyNthFrame")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub every_nth_frame: Option<i64>,
#[serde(rename = "maxFramesInFlight")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub max_frames_in_flight: Option<i64>,
#[serde(rename = "sendLastFrame")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub send_last_frame: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for StartScreencastParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StartScreencastParams;
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 = "format")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub format: Option<StartScreencastParamsFormat>,
#[serde(rename = "quality")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub quality: Option<i64>,
#[serde(rename = "maxWidth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub max_width: Option<i64>,
#[serde(rename = "maxHeight")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub max_height: Option<i64>,
#[serde(rename = "everyNthFrame")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub every_nth_frame: Option<i64>,
#[serde(rename = "maxFramesInFlight")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub max_frames_in_flight: Option<i64>,
#[serde(rename = "sendLastFrame")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub send_last_frame: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(StartScreencastParams {
format: fields.format,
quality: fields.quality,
max_width: fields.max_width,
max_height: fields.max_height,
every_nth_frame: fields.every_nth_frame,
max_frames_in_flight: fields.max_frames_in_flight,
send_last_frame: fields.send_last_frame,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct StartScreencast;
#[derive(Debug, Clone, serde::Serialize)]
pub struct StartScreencastResponse {}
impl<'de> serde::Deserialize<'de> for StartScreencastResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StartScreencastResponse;
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(StartScreencastResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for StartScreencast {
type Params = StartScreencastParams;
type Response = StartScreencastResponse;
const METHOD: &'static str = "Page.startScreencast";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct StopLoadingParams {}
impl<'de> serde::Deserialize<'de> for StopLoadingParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StopLoadingParams;
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(StopLoadingParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct StopLoading;
#[derive(Debug, Clone, serde::Serialize)]
pub struct StopLoadingResponse {}
impl<'de> serde::Deserialize<'de> for StopLoadingResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StopLoadingResponse;
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(StopLoadingResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for StopLoading {
type Params = StopLoadingParams;
type Response = StopLoadingResponse;
const METHOD: &'static str = "Page.stopLoading";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct StopScreenRecordingParams {}
impl<'de> serde::Deserialize<'de> for StopScreenRecordingParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StopScreenRecordingParams;
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(StopScreenRecordingParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct StopScreenRecording;
#[derive(Debug, Clone, serde::Serialize)]
pub struct StopScreenRecordingResponse {
#[serde(rename = "stream")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub stream: crate::io::types::StreamHandle,
}
impl<'de> serde::Deserialize<'de> for StopScreenRecordingResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StopScreenRecordingResponse;
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 = "stream")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub stream: crate::io::types::StreamHandle,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(StopScreenRecordingResponse {
stream: fields.stream,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for StopScreenRecording {
type Params = StopScreenRecordingParams;
type Response = StopScreenRecordingResponse;
const METHOD: &'static str = "Page.stopScreenRecording";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct StopScreencastParams {}
impl<'de> serde::Deserialize<'de> for StopScreencastParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StopScreencastParams;
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(StopScreencastParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct StopScreencast;
#[derive(Debug, Clone, serde::Serialize)]
pub struct StopScreencastResponse {}
impl<'de> serde::Deserialize<'de> for StopScreencastResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StopScreencastResponse;
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(StopScreencastResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for StopScreencast {
type Params = StopScreencastParams;
type Response = StopScreencastResponse;
const METHOD: &'static str = "Page.stopScreencast";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct WaitForDebuggerParams {}
impl<'de> serde::Deserialize<'de> for WaitForDebuggerParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = WaitForDebuggerParams;
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(WaitForDebuggerParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct WaitForDebugger;
#[derive(Debug, Clone, serde::Serialize)]
pub struct WaitForDebuggerResponse {}
impl<'de> serde::Deserialize<'de> for WaitForDebuggerResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = WaitForDebuggerResponse;
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(WaitForDebuggerResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for WaitForDebugger {
type Params = WaitForDebuggerParams;
type Response = WaitForDebuggerResponse;
const METHOD: &'static str = "Page.waitForDebugger";
}