#[derive(Debug, Clone, serde::Serialize)]
pub struct AddMockCameraParams {
#[serde(rename = "deviceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub device_id: String,
}
impl<'de> serde::Deserialize<'de> for AddMockCameraParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddMockCameraParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "deviceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub device_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddMockCameraParams {
device_id: fields.device_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AddMockCamera;
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddMockCameraResponse {}
impl<'de> serde::Deserialize<'de> for AddMockCameraResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddMockCameraResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(AddMockCameraResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for AddMockCamera {
type Params = AddMockCameraParams;
type Response = AddMockCameraResponse;
const METHOD: &'static str = "Browser.addMockCamera";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddPrivacySandboxEnrollmentOverrideParams {
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
}
impl<'de> serde::Deserialize<'de> for AddPrivacySandboxEnrollmentOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddPrivacySandboxEnrollmentOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "url")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub url: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddPrivacySandboxEnrollmentOverrideParams { url: fields.url })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AddPrivacySandboxEnrollmentOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddPrivacySandboxEnrollmentOverrideResponse {}
impl<'de> serde::Deserialize<'de> for AddPrivacySandboxEnrollmentOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddPrivacySandboxEnrollmentOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(AddPrivacySandboxEnrollmentOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for AddPrivacySandboxEnrollmentOverride {
type Params = AddPrivacySandboxEnrollmentOverrideParams;
type Response = AddPrivacySandboxEnrollmentOverrideResponse;
const METHOD: &'static str = "Browser.addPrivacySandboxEnrollmentOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct CancelDownloadParams {
#[serde(rename = "guid")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub guid: String,
#[serde(rename = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
}
impl<'de> serde::Deserialize<'de> for CancelDownloadParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CancelDownloadParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "guid")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub guid: String,
#[serde(rename = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CancelDownloadParams {
guid: fields.guid,
browser_context_id: fields.browser_context_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct CancelDownload;
#[derive(Debug, Clone, serde::Serialize)]
pub struct CancelDownloadResponse {}
impl<'de> serde::Deserialize<'de> for CancelDownloadResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CancelDownloadResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(CancelDownloadResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for CancelDownload {
type Params = CancelDownloadParams;
type Response = CancelDownloadResponse;
const METHOD: &'static str = "Browser.cancelDownload";
}
#[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 = "Browser.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 = "Browser.crash";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct CrashGpuProcessParams {}
impl<'de> serde::Deserialize<'de> for CrashGpuProcessParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CrashGpuProcessParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(CrashGpuProcessParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct CrashGpuProcess;
#[derive(Debug, Clone, serde::Serialize)]
pub struct CrashGpuProcessResponse {}
impl<'de> serde::Deserialize<'de> for CrashGpuProcessResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CrashGpuProcessResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(CrashGpuProcessResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for CrashGpuProcess {
type Params = CrashGpuProcessParams;
type Response = CrashGpuProcessResponse;
const METHOD: &'static str = "Browser.crashGpuProcess";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ExecuteBrowserCommandParams {
#[serde(rename = "commandId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub command_id: crate::browser::types::BrowserCommandId,
}
impl<'de> serde::Deserialize<'de> for ExecuteBrowserCommandParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ExecuteBrowserCommandParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "commandId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub command_id: crate::browser::types::BrowserCommandId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ExecuteBrowserCommandParams {
command_id: fields.command_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ExecuteBrowserCommand;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ExecuteBrowserCommandResponse {}
impl<'de> serde::Deserialize<'de> for ExecuteBrowserCommandResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ExecuteBrowserCommandResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ExecuteBrowserCommandResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ExecuteBrowserCommand {
type Params = ExecuteBrowserCommandParams;
type Response = ExecuteBrowserCommandResponse;
const METHOD: &'static str = "Browser.executeBrowserCommand";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetBrowserCommandLineParams {}
impl<'de> serde::Deserialize<'de> for GetBrowserCommandLineParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetBrowserCommandLineParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(GetBrowserCommandLineParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetBrowserCommandLine;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetBrowserCommandLineResponse {
#[serde(rename = "arguments")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub arguments: Vec<String>,
}
impl<'de> serde::Deserialize<'de> for GetBrowserCommandLineResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetBrowserCommandLineResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "arguments")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub arguments: Vec<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetBrowserCommandLineResponse {
arguments: fields.arguments,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetBrowserCommandLine {
type Params = GetBrowserCommandLineParams;
type Response = GetBrowserCommandLineResponse;
const METHOD: &'static str = "Browser.getBrowserCommandLine";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetGlobalPrivacyControlParams {}
impl<'de> serde::Deserialize<'de> for GetGlobalPrivacyControlParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetGlobalPrivacyControlParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(GetGlobalPrivacyControlParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetGlobalPrivacyControl;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetGlobalPrivacyControlResponse {
#[serde(rename = "gpc")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub gpc: bool,
}
impl<'de> serde::Deserialize<'de> for GetGlobalPrivacyControlResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetGlobalPrivacyControlResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "gpc")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub gpc: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetGlobalPrivacyControlResponse { gpc: fields.gpc })
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetGlobalPrivacyControl {
type Params = GetGlobalPrivacyControlParams;
type Response = GetGlobalPrivacyControlResponse;
const METHOD: &'static str = "Browser.getGlobalPrivacyControl";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetHistogramParams {
#[serde(rename = "name")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub name: String,
#[serde(rename = "delta")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub delta: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for GetHistogramParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetHistogramParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "name")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub name: String,
#[serde(rename = "delta")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub delta: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetHistogramParams {
name: fields.name,
delta: fields.delta,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetHistogram;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetHistogramResponse {
#[serde(rename = "histogram")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub histogram: crate::browser::types::Histogram,
}
impl<'de> serde::Deserialize<'de> for GetHistogramResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetHistogramResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "histogram")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub histogram: crate::browser::types::Histogram,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetHistogramResponse {
histogram: fields.histogram,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetHistogram {
type Params = GetHistogramParams;
type Response = GetHistogramResponse;
const METHOD: &'static str = "Browser.getHistogram";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetHistogramsParams {
#[serde(rename = "query")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub query: Option<String>,
#[serde(rename = "delta")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub delta: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for GetHistogramsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetHistogramsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "query")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub query: Option<String>,
#[serde(rename = "delta")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub delta: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetHistogramsParams {
query: fields.query,
delta: fields.delta,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetHistograms;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetHistogramsResponse {
#[serde(rename = "histograms")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub histograms: Vec<crate::browser::types::Histogram>,
}
impl<'de> serde::Deserialize<'de> for GetHistogramsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetHistogramsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "histograms")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub histograms: Vec<crate::browser::types::Histogram>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetHistogramsResponse {
histograms: fields.histograms,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetHistograms {
type Params = GetHistogramsParams;
type Response = GetHistogramsResponse;
const METHOD: &'static str = "Browser.getHistograms";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetVersionParams {}
impl<'de> serde::Deserialize<'de> for GetVersionParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetVersionParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(GetVersionParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetVersion;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetVersionResponse {
#[serde(rename = "protocolVersion")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub protocol_version: String,
#[serde(rename = "product")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub product: String,
#[serde(rename = "revision")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub revision: String,
#[serde(rename = "userAgent")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub user_agent: String,
#[serde(rename = "jsVersion")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub js_version: String,
}
impl<'de> serde::Deserialize<'de> for GetVersionResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetVersionResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "protocolVersion")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub protocol_version: String,
#[serde(rename = "product")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub product: String,
#[serde(rename = "revision")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub revision: String,
#[serde(rename = "userAgent")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub user_agent: String,
#[serde(rename = "jsVersion")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub js_version: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetVersionResponse {
protocol_version: fields.protocol_version,
product: fields.product,
revision: fields.revision,
user_agent: fields.user_agent,
js_version: fields.js_version,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetVersion {
type Params = GetVersionParams;
type Response = GetVersionResponse;
const METHOD: &'static str = "Browser.getVersion";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetWindowBoundsParams {
#[serde(rename = "windowId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub window_id: crate::browser::types::WindowId,
}
impl<'de> serde::Deserialize<'de> for GetWindowBoundsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetWindowBoundsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "windowId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub window_id: crate::browser::types::WindowId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetWindowBoundsParams {
window_id: fields.window_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetWindowBounds;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetWindowBoundsResponse {
#[serde(rename = "bounds")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub bounds: crate::browser::types::Bounds,
}
impl<'de> serde::Deserialize<'de> for GetWindowBoundsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetWindowBoundsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "bounds")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub bounds: crate::browser::types::Bounds,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetWindowBoundsResponse {
bounds: fields.bounds,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetWindowBounds {
type Params = GetWindowBoundsParams;
type Response = GetWindowBoundsResponse;
const METHOD: &'static str = "Browser.getWindowBounds";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetWindowForTargetParams {
#[serde(rename = "targetId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub target_id: Option<crate::target::types::TargetId>,
}
impl<'de> serde::Deserialize<'de> for GetWindowForTargetParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetWindowForTargetParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "targetId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub target_id: Option<crate::target::types::TargetId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetWindowForTargetParams {
target_id: fields.target_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetWindowForTarget;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetWindowForTargetResponse {
#[serde(rename = "windowId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub window_id: crate::browser::types::WindowId,
#[serde(rename = "bounds")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub bounds: crate::browser::types::Bounds,
}
impl<'de> serde::Deserialize<'de> for GetWindowForTargetResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetWindowForTargetResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "windowId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub window_id: crate::browser::types::WindowId,
#[serde(rename = "bounds")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub bounds: crate::browser::types::Bounds,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetWindowForTargetResponse {
window_id: fields.window_id,
bounds: fields.bounds,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetWindowForTarget {
type Params = GetWindowForTargetParams;
type Response = GetWindowForTargetResponse;
const METHOD: &'static str = "Browser.getWindowForTarget";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GrantPermissionsParams {
#[serde(rename = "permissions")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub permissions: Vec<crate::browser::types::PermissionType>,
#[serde(rename = "origin")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub origin: Option<String>,
#[serde(rename = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
}
impl<'de> serde::Deserialize<'de> for GrantPermissionsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GrantPermissionsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "permissions")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub permissions: Vec<crate::browser::types::PermissionType>,
#[serde(rename = "origin")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub origin: Option<String>,
#[serde(rename = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GrantPermissionsParams {
permissions: fields.permissions,
origin: fields.origin,
browser_context_id: fields.browser_context_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GrantPermissions;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GrantPermissionsResponse {}
impl<'de> serde::Deserialize<'de> for GrantPermissionsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GrantPermissionsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(GrantPermissionsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GrantPermissions {
type Params = GrantPermissionsParams;
type Response = GrantPermissionsResponse;
const METHOD: &'static str = "Browser.grantPermissions";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct ResetPermissionsParams {
#[serde(rename = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
}
impl<'de> serde::Deserialize<'de> for ResetPermissionsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResetPermissionsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ResetPermissionsParams {
browser_context_id: fields.browser_context_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ResetPermissions;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ResetPermissionsResponse {}
impl<'de> serde::Deserialize<'de> for ResetPermissionsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResetPermissionsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ResetPermissionsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ResetPermissions {
type Params = ResetPermissionsParams;
type Response = ResetPermissionsResponse;
const METHOD: &'static str = "Browser.resetPermissions";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetContentsSizeParams {
#[serde(rename = "windowId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub window_id: crate::browser::types::WindowId,
#[serde(rename = "width")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub width: Option<i64>,
#[serde(rename = "height")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub height: Option<i64>,
}
impl<'de> serde::Deserialize<'de> for SetContentsSizeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetContentsSizeParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "windowId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub window_id: crate::browser::types::WindowId,
#[serde(rename = "width")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub width: Option<i64>,
#[serde(rename = "height")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub height: Option<i64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetContentsSizeParams {
window_id: fields.window_id,
width: fields.width,
height: fields.height,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetContentsSize;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetContentsSizeResponse {}
impl<'de> serde::Deserialize<'de> for SetContentsSizeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetContentsSizeResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetContentsSizeResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetContentsSize {
type Params = SetContentsSizeParams;
type Response = SetContentsSizeResponse;
const METHOD: &'static str = "Browser.setContentsSize";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct SetDockTileParams {
#[serde(rename = "badgeLabel")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub badge_label: Option<String>,
#[serde(rename = "image")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub image: Option<String>,
}
impl<'de> serde::Deserialize<'de> for SetDockTileParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDockTileParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "badgeLabel")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub badge_label: Option<String>,
#[serde(rename = "image")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub image: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetDockTileParams {
badge_label: fields.badge_label,
image: fields.image,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetDockTile;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDockTileResponse {}
impl<'de> serde::Deserialize<'de> for SetDockTileResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDockTileResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetDockTileResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetDockTile {
type Params = SetDockTileParams;
type Response = SetDockTileResponse;
const METHOD: &'static str = "Browser.setDockTile";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum SetDownloadBehaviorParamsBehavior {
Deny,
Allow,
AllowAndName,
Default,
Unknown(String),
}
impl SetDownloadBehaviorParamsBehavior {
pub fn as_str(&self) -> &str {
match self {
Self::Deny => "deny",
Self::Allow => "allow",
Self::AllowAndName => "allowAndName",
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,
"allowAndName" => SetDownloadBehaviorParamsBehavior::AllowAndName,
"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,
"allowAndName" => SetDownloadBehaviorParamsBehavior::AllowAndName,
"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 = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
#[serde(rename = "downloadPath")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub download_path: Option<String>,
#[serde(rename = "eventsEnabled")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub events_enabled: Option<bool>,
}
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 = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
#[serde(rename = "downloadPath")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub download_path: Option<String>,
#[serde(rename = "eventsEnabled")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub events_enabled: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetDownloadBehaviorParams {
behavior: fields.behavior,
browser_context_id: fields.browser_context_id,
download_path: fields.download_path,
events_enabled: fields.events_enabled,
})
}
}
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 = "Browser.setDownloadBehavior";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetGlobalPrivacyControlParams {
#[serde(rename = "gpc")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub gpc: bool,
}
impl<'de> serde::Deserialize<'de> for SetGlobalPrivacyControlParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetGlobalPrivacyControlParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "gpc")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub gpc: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetGlobalPrivacyControlParams { gpc: fields.gpc })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetGlobalPrivacyControl;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetGlobalPrivacyControlResponse {
#[serde(rename = "gpc")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub gpc: bool,
}
impl<'de> serde::Deserialize<'de> for SetGlobalPrivacyControlResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetGlobalPrivacyControlResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "gpc")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub gpc: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetGlobalPrivacyControlResponse { gpc: fields.gpc })
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetGlobalPrivacyControl {
type Params = SetGlobalPrivacyControlParams;
type Response = SetGlobalPrivacyControlResponse;
const METHOD: &'static str = "Browser.setGlobalPrivacyControl";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPermissionParams {
#[serde(rename = "permission")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub permission: crate::browser::types::PermissionDescriptor,
#[serde(rename = "setting")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub setting: crate::browser::types::PermissionSetting,
#[serde(rename = "origin")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub origin: Option<String>,
#[serde(rename = "embeddedOrigin")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub embedded_origin: Option<String>,
#[serde(rename = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
}
impl<'de> serde::Deserialize<'de> for SetPermissionParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPermissionParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "permission")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub permission: crate::browser::types::PermissionDescriptor,
#[serde(rename = "setting")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub setting: crate::browser::types::PermissionSetting,
#[serde(rename = "origin")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub origin: Option<String>,
#[serde(rename = "embeddedOrigin")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub embedded_origin: Option<String>,
#[serde(rename = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetPermissionParams {
permission: fields.permission,
setting: fields.setting,
origin: fields.origin,
embedded_origin: fields.embedded_origin,
browser_context_id: fields.browser_context_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetPermission;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPermissionResponse {}
impl<'de> serde::Deserialize<'de> for SetPermissionResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPermissionResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetPermissionResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetPermission {
type Params = SetPermissionParams;
type Response = SetPermissionResponse;
const METHOD: &'static str = "Browser.setPermission";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetWindowBoundsParams {
#[serde(rename = "windowId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub window_id: crate::browser::types::WindowId,
#[serde(rename = "bounds")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub bounds: crate::browser::types::Bounds,
}
impl<'de> serde::Deserialize<'de> for SetWindowBoundsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetWindowBoundsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "windowId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub window_id: crate::browser::types::WindowId,
#[serde(rename = "bounds")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub bounds: crate::browser::types::Bounds,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetWindowBoundsParams {
window_id: fields.window_id,
bounds: fields.bounds,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetWindowBounds;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetWindowBoundsResponse {}
impl<'de> serde::Deserialize<'de> for SetWindowBoundsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetWindowBoundsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetWindowBoundsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetWindowBounds {
type Params = SetWindowBoundsParams;
type Response = SetWindowBoundsResponse;
const METHOD: &'static str = "Browser.setWindowBounds";
}