#[derive(Debug, Clone, serde::Serialize)]
pub struct AddScreenParams {
#[serde(rename = "left")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub left: i64,
#[serde(rename = "top")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub top: i64,
#[serde(rename = "width")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub width: i64,
#[serde(rename = "height")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub height: i64,
#[serde(rename = "workAreaInsets")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub work_area_insets: Option<crate::emulation::types::WorkAreaInsets>,
#[serde(rename = "devicePixelRatio")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub device_pixel_ratio: Option<ydp_core::FiniteF64>,
#[serde(rename = "rotation")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub rotation: Option<i64>,
#[serde(rename = "colorDepth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub color_depth: Option<i64>,
#[serde(rename = "label")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub label: Option<String>,
#[serde(rename = "isInternal")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub is_internal: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for AddScreenParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddScreenParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "left")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub left: i64,
#[serde(rename = "top")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub top: i64,
#[serde(rename = "width")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub width: i64,
#[serde(rename = "height")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub height: i64,
#[serde(rename = "workAreaInsets")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub work_area_insets: Option<crate::emulation::types::WorkAreaInsets>,
#[serde(rename = "devicePixelRatio")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub device_pixel_ratio: Option<ydp_core::FiniteF64>,
#[serde(rename = "rotation")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub rotation: Option<i64>,
#[serde(rename = "colorDepth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub color_depth: Option<i64>,
#[serde(rename = "label")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub label: Option<String>,
#[serde(rename = "isInternal")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub is_internal: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddScreenParams {
left: fields.left,
top: fields.top,
width: fields.width,
height: fields.height,
work_area_insets: fields.work_area_insets,
device_pixel_ratio: fields.device_pixel_ratio,
rotation: fields.rotation,
color_depth: fields.color_depth,
label: fields.label,
is_internal: fields.is_internal,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AddScreen;
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddScreenResponse {
#[serde(rename = "screenInfo")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub screen_info: crate::emulation::types::ScreenInfo,
}
impl<'de> serde::Deserialize<'de> for AddScreenResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddScreenResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "screenInfo")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub screen_info: crate::emulation::types::ScreenInfo,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddScreenResponse {
screen_info: fields.screen_info,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for AddScreen {
type Params = AddScreenParams;
type Response = AddScreenResponse;
const METHOD: &'static str = "Emulation.addScreen";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct CanEmulateParams {}
impl<'de> serde::Deserialize<'de> for CanEmulateParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CanEmulateParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(CanEmulateParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct CanEmulate;
#[derive(Debug, Clone, serde::Serialize)]
pub struct CanEmulateResponse {
#[serde(rename = "result")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub result: bool,
}
impl<'de> serde::Deserialize<'de> for CanEmulateResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CanEmulateResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "result")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub result: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CanEmulateResponse {
result: fields.result,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for CanEmulate {
type Params = CanEmulateParams;
type Response = CanEmulateResponse;
const METHOD: &'static str = "Emulation.canEmulate";
}
#[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 = "Emulation.clearDeviceMetricsOverride";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct ClearDevicePostureOverrideParams {}
impl<'de> serde::Deserialize<'de> for ClearDevicePostureOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearDevicePostureOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ClearDevicePostureOverrideParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ClearDevicePostureOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearDevicePostureOverrideResponse {}
impl<'de> serde::Deserialize<'de> for ClearDevicePostureOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearDevicePostureOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ClearDevicePostureOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ClearDevicePostureOverride {
type Params = ClearDevicePostureOverrideParams;
type Response = ClearDevicePostureOverrideResponse;
const METHOD: &'static str = "Emulation.clearDevicePostureOverride";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct ClearDisplayFeaturesOverrideParams {}
impl<'de> serde::Deserialize<'de> for ClearDisplayFeaturesOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearDisplayFeaturesOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ClearDisplayFeaturesOverrideParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ClearDisplayFeaturesOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearDisplayFeaturesOverrideResponse {}
impl<'de> serde::Deserialize<'de> for ClearDisplayFeaturesOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearDisplayFeaturesOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ClearDisplayFeaturesOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ClearDisplayFeaturesOverride {
type Params = ClearDisplayFeaturesOverrideParams;
type Response = ClearDisplayFeaturesOverrideResponse;
const METHOD: &'static str = "Emulation.clearDisplayFeaturesOverride";
}
#[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 = "Emulation.clearGeolocationOverride";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct ClearIdleOverrideParams {}
impl<'de> serde::Deserialize<'de> for ClearIdleOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearIdleOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ClearIdleOverrideParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ClearIdleOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearIdleOverrideResponse {}
impl<'de> serde::Deserialize<'de> for ClearIdleOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearIdleOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ClearIdleOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ClearIdleOverride {
type Params = ClearIdleOverrideParams;
type Response = ClearIdleOverrideResponse;
const METHOD: &'static str = "Emulation.clearIdleOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetOverriddenSensorInformationParams {
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::emulation::types::SensorType,
}
impl<'de> serde::Deserialize<'de> for GetOverriddenSensorInformationParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetOverriddenSensorInformationParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::emulation::types::SensorType,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetOverriddenSensorInformationParams {
r#type: fields.r#type,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetOverriddenSensorInformation;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetOverriddenSensorInformationResponse {
#[serde(rename = "requestedSamplingFrequency")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub requested_sampling_frequency: ydp_core::FiniteF64,
}
impl<'de> serde::Deserialize<'de> for GetOverriddenSensorInformationResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetOverriddenSensorInformationResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "requestedSamplingFrequency")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub requested_sampling_frequency: ydp_core::FiniteF64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetOverriddenSensorInformationResponse {
requested_sampling_frequency: fields.requested_sampling_frequency,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetOverriddenSensorInformation {
type Params = GetOverriddenSensorInformationParams;
type Response = GetOverriddenSensorInformationResponse;
const METHOD: &'static str = "Emulation.getOverriddenSensorInformation";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetScreenInfosParams {}
impl<'de> serde::Deserialize<'de> for GetScreenInfosParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetScreenInfosParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(GetScreenInfosParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetScreenInfos;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetScreenInfosResponse {
#[serde(rename = "screenInfos")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub screen_infos: Vec<crate::emulation::types::ScreenInfo>,
}
impl<'de> serde::Deserialize<'de> for GetScreenInfosResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetScreenInfosResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "screenInfos")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub screen_infos: Vec<crate::emulation::types::ScreenInfo>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetScreenInfosResponse {
screen_infos: fields.screen_infos,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetScreenInfos {
type Params = GetScreenInfosParams;
type Response = GetScreenInfosResponse;
const METHOD: &'static str = "Emulation.getScreenInfos";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveScreenParams {
#[serde(rename = "screenId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub screen_id: crate::emulation::types::ScreenId,
}
impl<'de> serde::Deserialize<'de> for RemoveScreenParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveScreenParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "screenId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub screen_id: crate::emulation::types::ScreenId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RemoveScreenParams {
screen_id: fields.screen_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RemoveScreen;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveScreenResponse {}
impl<'de> serde::Deserialize<'de> for RemoveScreenResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveScreenResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(RemoveScreenResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RemoveScreen {
type Params = RemoveScreenParams;
type Response = RemoveScreenResponse;
const METHOD: &'static str = "Emulation.removeScreen";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct ResetPageScaleFactorParams {}
impl<'de> serde::Deserialize<'de> for ResetPageScaleFactorParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResetPageScaleFactorParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ResetPageScaleFactorParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ResetPageScaleFactor;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ResetPageScaleFactorResponse {}
impl<'de> serde::Deserialize<'de> for ResetPageScaleFactorResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResetPageScaleFactorResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ResetPageScaleFactorResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ResetPageScaleFactor {
type Params = ResetPageScaleFactorParams;
type Response = ResetPageScaleFactorResponse;
const METHOD: &'static str = "Emulation.resetPageScaleFactor";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct SetAutoDarkModeOverrideParams {
#[serde(rename = "enabled")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub enabled: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for SetAutoDarkModeOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetAutoDarkModeOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub enabled: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetAutoDarkModeOverrideParams {
enabled: fields.enabled,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetAutoDarkModeOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetAutoDarkModeOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetAutoDarkModeOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetAutoDarkModeOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetAutoDarkModeOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetAutoDarkModeOverride {
type Params = SetAutoDarkModeOverrideParams;
type Response = SetAutoDarkModeOverrideResponse;
const METHOD: &'static str = "Emulation.setAutoDarkModeOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetAutomationOverrideParams {
#[serde(rename = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
}
impl<'de> serde::Deserialize<'de> for SetAutomationOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetAutomationOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetAutomationOverrideParams {
enabled: fields.enabled,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetAutomationOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetAutomationOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetAutomationOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetAutomationOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetAutomationOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetAutomationOverride {
type Params = SetAutomationOverrideParams;
type Response = SetAutomationOverrideResponse;
const METHOD: &'static str = "Emulation.setAutomationOverride";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum SetCpuPerformanceOverrideParamsPerformanceTier {
KnownUnknown,
Low,
Mid,
High,
Ultra,
Unknown(String),
}
impl SetCpuPerformanceOverrideParamsPerformanceTier {
pub fn as_str(&self) -> &str {
match self {
Self::KnownUnknown => "unknown",
Self::Low => "low",
Self::Mid => "mid",
Self::High => "high",
Self::Ultra => "ultra",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for SetCpuPerformanceOverrideParamsPerformanceTier {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for SetCpuPerformanceOverrideParamsPerformanceTier {
fn from(value: String) -> Self {
match value.as_str() {
"unknown" => SetCpuPerformanceOverrideParamsPerformanceTier::KnownUnknown,
"low" => SetCpuPerformanceOverrideParamsPerformanceTier::Low,
"mid" => SetCpuPerformanceOverrideParamsPerformanceTier::Mid,
"high" => SetCpuPerformanceOverrideParamsPerformanceTier::High,
"ultra" => SetCpuPerformanceOverrideParamsPerformanceTier::Ultra,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for SetCpuPerformanceOverrideParamsPerformanceTier {
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 SetCpuPerformanceOverrideParamsPerformanceTier {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetCpuPerformanceOverrideParamsPerformanceTier;
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 {
"unknown" => SetCpuPerformanceOverrideParamsPerformanceTier::KnownUnknown,
"low" => SetCpuPerformanceOverrideParamsPerformanceTier::Low,
"mid" => SetCpuPerformanceOverrideParamsPerformanceTier::Mid,
"high" => SetCpuPerformanceOverrideParamsPerformanceTier::High,
"ultra" => SetCpuPerformanceOverrideParamsPerformanceTier::Ultra,
_ => SetCpuPerformanceOverrideParamsPerformanceTier::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(SetCpuPerformanceOverrideParamsPerformanceTier::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct SetCpuPerformanceOverrideParams {
#[serde(rename = "performanceTier")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub performance_tier: Option<SetCpuPerformanceOverrideParamsPerformanceTier>,
}
impl<'de> serde::Deserialize<'de> for SetCpuPerformanceOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetCpuPerformanceOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "performanceTier")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub performance_tier: Option<SetCpuPerformanceOverrideParamsPerformanceTier>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetCpuPerformanceOverrideParams {
performance_tier: fields.performance_tier,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetCpuPerformanceOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetCpuPerformanceOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetCpuPerformanceOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetCpuPerformanceOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetCpuPerformanceOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetCpuPerformanceOverride {
type Params = SetCpuPerformanceOverrideParams;
type Response = SetCpuPerformanceOverrideResponse;
const METHOD: &'static str = "Emulation.setCPUPerformanceOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetCpuThrottlingRateParams {
#[serde(rename = "rate")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub rate: ydp_core::FiniteF64,
}
impl<'de> serde::Deserialize<'de> for SetCpuThrottlingRateParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetCpuThrottlingRateParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "rate")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub rate: ydp_core::FiniteF64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetCpuThrottlingRateParams { rate: fields.rate })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetCpuThrottlingRate;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetCpuThrottlingRateResponse {}
impl<'de> serde::Deserialize<'de> for SetCpuThrottlingRateResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetCpuThrottlingRateResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetCpuThrottlingRateResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetCpuThrottlingRate {
type Params = SetCpuThrottlingRateParams;
type Response = SetCpuThrottlingRateResponse;
const METHOD: &'static str = "Emulation.setCPUThrottlingRate";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct SetDataSaverOverrideParams {
#[serde(rename = "dataSaverEnabled")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub data_saver_enabled: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for SetDataSaverOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDataSaverOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "dataSaverEnabled")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub data_saver_enabled: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetDataSaverOverrideParams {
data_saver_enabled: fields.data_saver_enabled,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetDataSaverOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDataSaverOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetDataSaverOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDataSaverOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetDataSaverOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetDataSaverOverride {
type Params = SetDataSaverOverrideParams;
type Response = SetDataSaverOverrideResponse;
const METHOD: &'static str = "Emulation.setDataSaverOverride";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct SetDefaultBackgroundColorOverrideParams {
#[serde(rename = "color")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub color: Option<crate::dom::types::Rgba>,
}
impl<'de> serde::Deserialize<'de> for SetDefaultBackgroundColorOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDefaultBackgroundColorOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "color")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub color: Option<crate::dom::types::Rgba>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetDefaultBackgroundColorOverrideParams {
color: fields.color,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetDefaultBackgroundColorOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDefaultBackgroundColorOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetDefaultBackgroundColorOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDefaultBackgroundColorOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetDefaultBackgroundColorOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetDefaultBackgroundColorOverride {
type Params = SetDefaultBackgroundColorOverrideParams;
type Response = SetDefaultBackgroundColorOverrideResponse;
const METHOD: &'static str = "Emulation.setDefaultBackgroundColorOverride";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum SetDeviceMetricsOverrideParamsScrollbarType {
Overlay,
Default,
Unknown(String),
}
impl SetDeviceMetricsOverrideParamsScrollbarType {
pub fn as_str(&self) -> &str {
match self {
Self::Overlay => "overlay",
Self::Default => "default",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for SetDeviceMetricsOverrideParamsScrollbarType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for SetDeviceMetricsOverrideParamsScrollbarType {
fn from(value: String) -> Self {
match value.as_str() {
"overlay" => SetDeviceMetricsOverrideParamsScrollbarType::Overlay,
"default" => SetDeviceMetricsOverrideParamsScrollbarType::Default,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for SetDeviceMetricsOverrideParamsScrollbarType {
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 SetDeviceMetricsOverrideParamsScrollbarType {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDeviceMetricsOverrideParamsScrollbarType;
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 {
"overlay" => SetDeviceMetricsOverrideParamsScrollbarType::Overlay,
"default" => SetDeviceMetricsOverrideParamsScrollbarType::Default,
_ => SetDeviceMetricsOverrideParamsScrollbarType::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(SetDeviceMetricsOverrideParamsScrollbarType::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum SetDeviceMetricsOverrideParamsViewportMeta {
Enable,
Default,
Unknown(String),
}
impl SetDeviceMetricsOverrideParamsViewportMeta {
pub fn as_str(&self) -> &str {
match self {
Self::Enable => "enable",
Self::Default => "default",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for SetDeviceMetricsOverrideParamsViewportMeta {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for SetDeviceMetricsOverrideParamsViewportMeta {
fn from(value: String) -> Self {
match value.as_str() {
"enable" => SetDeviceMetricsOverrideParamsViewportMeta::Enable,
"default" => SetDeviceMetricsOverrideParamsViewportMeta::Default,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for SetDeviceMetricsOverrideParamsViewportMeta {
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 SetDeviceMetricsOverrideParamsViewportMeta {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDeviceMetricsOverrideParamsViewportMeta;
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 {
"enable" => SetDeviceMetricsOverrideParamsViewportMeta::Enable,
"default" => SetDeviceMetricsOverrideParamsViewportMeta::Default,
_ => SetDeviceMetricsOverrideParamsViewportMeta::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(SetDeviceMetricsOverrideParamsViewportMeta::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[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>,
#[serde(rename = "displayFeature")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub display_feature: Option<crate::emulation::types::DisplayFeature>,
#[serde(rename = "devicePosture")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub device_posture: Option<crate::emulation::types::DevicePosture>,
#[serde(rename = "scrollbarType")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub scrollbar_type: Option<SetDeviceMetricsOverrideParamsScrollbarType>,
#[serde(rename = "screenOrientationLockEmulation")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub screen_orientation_lock_emulation: Option<bool>,
#[serde(rename = "viewportMeta")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub viewport_meta: Option<SetDeviceMetricsOverrideParamsViewportMeta>,
}
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>,
#[serde(rename = "displayFeature")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub display_feature: Option<crate::emulation::types::DisplayFeature>,
#[serde(rename = "devicePosture")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub device_posture: Option<crate::emulation::types::DevicePosture>,
#[serde(rename = "scrollbarType")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub scrollbar_type: Option<SetDeviceMetricsOverrideParamsScrollbarType>,
#[serde(rename = "screenOrientationLockEmulation")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub screen_orientation_lock_emulation: Option<bool>,
#[serde(rename = "viewportMeta")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub viewport_meta: Option<SetDeviceMetricsOverrideParamsViewportMeta>,
}
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,
display_feature: fields.display_feature,
device_posture: fields.device_posture,
scrollbar_type: fields.scrollbar_type,
screen_orientation_lock_emulation: fields.screen_orientation_lock_emulation,
viewport_meta: fields.viewport_meta,
})
}
}
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 = "Emulation.setDeviceMetricsOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDevicePostureOverrideParams {
#[serde(rename = "posture")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub posture: crate::emulation::types::DevicePosture,
}
impl<'de> serde::Deserialize<'de> for SetDevicePostureOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDevicePostureOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "posture")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub posture: crate::emulation::types::DevicePosture,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetDevicePostureOverrideParams {
posture: fields.posture,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetDevicePostureOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDevicePostureOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetDevicePostureOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDevicePostureOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetDevicePostureOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetDevicePostureOverride {
type Params = SetDevicePostureOverrideParams;
type Response = SetDevicePostureOverrideResponse;
const METHOD: &'static str = "Emulation.setDevicePostureOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDisabledImageTypesParams {
#[serde(rename = "imageTypes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub image_types: Vec<crate::emulation::types::DisabledImageType>,
}
impl<'de> serde::Deserialize<'de> for SetDisabledImageTypesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDisabledImageTypesParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "imageTypes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub image_types: Vec<crate::emulation::types::DisabledImageType>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetDisabledImageTypesParams {
image_types: fields.image_types,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetDisabledImageTypes;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDisabledImageTypesResponse {}
impl<'de> serde::Deserialize<'de> for SetDisabledImageTypesResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDisabledImageTypesResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetDisabledImageTypesResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetDisabledImageTypes {
type Params = SetDisabledImageTypesParams;
type Response = SetDisabledImageTypesResponse;
const METHOD: &'static str = "Emulation.setDisabledImageTypes";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDisplayFeaturesOverrideParams {
#[serde(rename = "features")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub features: Vec<crate::emulation::types::DisplayFeature>,
}
impl<'de> serde::Deserialize<'de> for SetDisplayFeaturesOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDisplayFeaturesOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "features")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub features: Vec<crate::emulation::types::DisplayFeature>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetDisplayFeaturesOverrideParams {
features: fields.features,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetDisplayFeaturesOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDisplayFeaturesOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetDisplayFeaturesOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDisplayFeaturesOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetDisplayFeaturesOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetDisplayFeaturesOverride {
type Params = SetDisplayFeaturesOverrideParams;
type Response = SetDisplayFeaturesOverrideResponse;
const METHOD: &'static str = "Emulation.setDisplayFeaturesOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDocumentCookieDisabledParams {
#[serde(rename = "disabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub disabled: bool,
}
impl<'de> serde::Deserialize<'de> for SetDocumentCookieDisabledParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDocumentCookieDisabledParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "disabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub disabled: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetDocumentCookieDisabledParams {
disabled: fields.disabled,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetDocumentCookieDisabled;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetDocumentCookieDisabledResponse {}
impl<'de> serde::Deserialize<'de> for SetDocumentCookieDisabledResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetDocumentCookieDisabledResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetDocumentCookieDisabledResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetDocumentCookieDisabled {
type Params = SetDocumentCookieDisabledParams;
type Response = SetDocumentCookieDisabledResponse;
const METHOD: &'static str = "Emulation.setDocumentCookieDisabled";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum SetEmitTouchEventsForMouseParamsConfiguration {
Mobile,
Desktop,
Unknown(String),
}
impl SetEmitTouchEventsForMouseParamsConfiguration {
pub fn as_str(&self) -> &str {
match self {
Self::Mobile => "mobile",
Self::Desktop => "desktop",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for SetEmitTouchEventsForMouseParamsConfiguration {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for SetEmitTouchEventsForMouseParamsConfiguration {
fn from(value: String) -> Self {
match value.as_str() {
"mobile" => SetEmitTouchEventsForMouseParamsConfiguration::Mobile,
"desktop" => SetEmitTouchEventsForMouseParamsConfiguration::Desktop,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for SetEmitTouchEventsForMouseParamsConfiguration {
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 SetEmitTouchEventsForMouseParamsConfiguration {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetEmitTouchEventsForMouseParamsConfiguration;
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" => SetEmitTouchEventsForMouseParamsConfiguration::Mobile,
"desktop" => SetEmitTouchEventsForMouseParamsConfiguration::Desktop,
_ => SetEmitTouchEventsForMouseParamsConfiguration::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(SetEmitTouchEventsForMouseParamsConfiguration::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetEmitTouchEventsForMouseParams {
#[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<SetEmitTouchEventsForMouseParamsConfiguration>,
}
impl<'de> serde::Deserialize<'de> for SetEmitTouchEventsForMouseParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetEmitTouchEventsForMouseParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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<SetEmitTouchEventsForMouseParamsConfiguration>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetEmitTouchEventsForMouseParams {
enabled: fields.enabled,
configuration: fields.configuration,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetEmitTouchEventsForMouse;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetEmitTouchEventsForMouseResponse {}
impl<'de> serde::Deserialize<'de> for SetEmitTouchEventsForMouseResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetEmitTouchEventsForMouseResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetEmitTouchEventsForMouseResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetEmitTouchEventsForMouse {
type Params = SetEmitTouchEventsForMouseParams;
type Response = SetEmitTouchEventsForMouseResponse;
const METHOD: &'static str = "Emulation.setEmitTouchEventsForMouse";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct SetEmulatedMediaParams {
#[serde(rename = "media")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub media: Option<String>,
#[serde(rename = "features")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub features: Option<Vec<crate::emulation::types::MediaFeature>>,
}
impl<'de> serde::Deserialize<'de> for SetEmulatedMediaParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetEmulatedMediaParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "media")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub media: Option<String>,
#[serde(rename = "features")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub features: Option<Vec<crate::emulation::types::MediaFeature>>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetEmulatedMediaParams {
media: fields.media,
features: fields.features,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetEmulatedMedia;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetEmulatedMediaResponse {}
impl<'de> serde::Deserialize<'de> for SetEmulatedMediaResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetEmulatedMediaResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetEmulatedMediaResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetEmulatedMedia {
type Params = SetEmulatedMediaParams;
type Response = SetEmulatedMediaResponse;
const METHOD: &'static str = "Emulation.setEmulatedMedia";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct SetEmulatedOsTextScaleParams {
#[serde(rename = "scale")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub scale: Option<ydp_core::FiniteF64>,
}
impl<'de> serde::Deserialize<'de> for SetEmulatedOsTextScaleParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetEmulatedOsTextScaleParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "scale")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub scale: Option<ydp_core::FiniteF64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetEmulatedOsTextScaleParams {
scale: fields.scale,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetEmulatedOsTextScale;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetEmulatedOsTextScaleResponse {}
impl<'de> serde::Deserialize<'de> for SetEmulatedOsTextScaleResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetEmulatedOsTextScaleResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetEmulatedOsTextScaleResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetEmulatedOsTextScale {
type Params = SetEmulatedOsTextScaleParams;
type Response = SetEmulatedOsTextScaleResponse;
const METHOD: &'static str = "Emulation.setEmulatedOSTextScale";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum SetEmulatedVisionDeficiencyParamsType {
None,
BlurredVision,
ReducedContrast,
Achromatopsia,
Deuteranopia,
Protanopia,
Tritanopia,
Unknown(String),
}
impl SetEmulatedVisionDeficiencyParamsType {
pub fn as_str(&self) -> &str {
match self {
Self::None => "none",
Self::BlurredVision => "blurredVision",
Self::ReducedContrast => "reducedContrast",
Self::Achromatopsia => "achromatopsia",
Self::Deuteranopia => "deuteranopia",
Self::Protanopia => "protanopia",
Self::Tritanopia => "tritanopia",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for SetEmulatedVisionDeficiencyParamsType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for SetEmulatedVisionDeficiencyParamsType {
fn from(value: String) -> Self {
match value.as_str() {
"none" => SetEmulatedVisionDeficiencyParamsType::None,
"blurredVision" => SetEmulatedVisionDeficiencyParamsType::BlurredVision,
"reducedContrast" => SetEmulatedVisionDeficiencyParamsType::ReducedContrast,
"achromatopsia" => SetEmulatedVisionDeficiencyParamsType::Achromatopsia,
"deuteranopia" => SetEmulatedVisionDeficiencyParamsType::Deuteranopia,
"protanopia" => SetEmulatedVisionDeficiencyParamsType::Protanopia,
"tritanopia" => SetEmulatedVisionDeficiencyParamsType::Tritanopia,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for SetEmulatedVisionDeficiencyParamsType {
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 SetEmulatedVisionDeficiencyParamsType {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetEmulatedVisionDeficiencyParamsType;
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" => SetEmulatedVisionDeficiencyParamsType::None,
"blurredVision" => SetEmulatedVisionDeficiencyParamsType::BlurredVision,
"reducedContrast" => SetEmulatedVisionDeficiencyParamsType::ReducedContrast,
"achromatopsia" => SetEmulatedVisionDeficiencyParamsType::Achromatopsia,
"deuteranopia" => SetEmulatedVisionDeficiencyParamsType::Deuteranopia,
"protanopia" => SetEmulatedVisionDeficiencyParamsType::Protanopia,
"tritanopia" => SetEmulatedVisionDeficiencyParamsType::Tritanopia,
_ => SetEmulatedVisionDeficiencyParamsType::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(SetEmulatedVisionDeficiencyParamsType::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetEmulatedVisionDeficiencyParams {
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: SetEmulatedVisionDeficiencyParamsType,
}
impl<'de> serde::Deserialize<'de> for SetEmulatedVisionDeficiencyParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetEmulatedVisionDeficiencyParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: SetEmulatedVisionDeficiencyParamsType,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetEmulatedVisionDeficiencyParams {
r#type: fields.r#type,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetEmulatedVisionDeficiency;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetEmulatedVisionDeficiencyResponse {}
impl<'de> serde::Deserialize<'de> for SetEmulatedVisionDeficiencyResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetEmulatedVisionDeficiencyResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetEmulatedVisionDeficiencyResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetEmulatedVisionDeficiency {
type Params = SetEmulatedVisionDeficiencyParams;
type Response = SetEmulatedVisionDeficiencyResponse;
const METHOD: &'static str = "Emulation.setEmulatedVisionDeficiency";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetFocusEmulationEnabledParams {
#[serde(rename = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
}
impl<'de> serde::Deserialize<'de> for SetFocusEmulationEnabledParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetFocusEmulationEnabledParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetFocusEmulationEnabledParams {
enabled: fields.enabled,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetFocusEmulationEnabled;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetFocusEmulationEnabledResponse {}
impl<'de> serde::Deserialize<'de> for SetFocusEmulationEnabledResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetFocusEmulationEnabledResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetFocusEmulationEnabledResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetFocusEmulationEnabled {
type Params = SetFocusEmulationEnabledParams;
type Response = SetFocusEmulationEnabledResponse;
const METHOD: &'static str = "Emulation.setFocusEmulationEnabled";
}
#[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>,
#[serde(rename = "altitude")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub altitude: Option<ydp_core::FiniteF64>,
#[serde(rename = "altitudeAccuracy")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub altitude_accuracy: Option<ydp_core::FiniteF64>,
#[serde(rename = "heading")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub heading: Option<ydp_core::FiniteF64>,
#[serde(rename = "speed")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub speed: 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>,
#[serde(rename = "altitude")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub altitude: Option<ydp_core::FiniteF64>,
#[serde(rename = "altitudeAccuracy")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub altitude_accuracy: Option<ydp_core::FiniteF64>,
#[serde(rename = "heading")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub heading: Option<ydp_core::FiniteF64>,
#[serde(rename = "speed")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub speed: 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,
altitude: fields.altitude,
altitude_accuracy: fields.altitude_accuracy,
heading: fields.heading,
speed: fields.speed,
})
}
}
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 = "Emulation.setGeolocationOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetHardwareConcurrencyOverrideParams {
#[serde(rename = "hardwareConcurrency")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub hardware_concurrency: i64,
}
impl<'de> serde::Deserialize<'de> for SetHardwareConcurrencyOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetHardwareConcurrencyOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "hardwareConcurrency")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub hardware_concurrency: i64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetHardwareConcurrencyOverrideParams {
hardware_concurrency: fields.hardware_concurrency,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetHardwareConcurrencyOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetHardwareConcurrencyOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetHardwareConcurrencyOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetHardwareConcurrencyOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetHardwareConcurrencyOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetHardwareConcurrencyOverride {
type Params = SetHardwareConcurrencyOverrideParams;
type Response = SetHardwareConcurrencyOverrideResponse;
const METHOD: &'static str = "Emulation.setHardwareConcurrencyOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetIdleOverrideParams {
#[serde(rename = "isUserActive")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub is_user_active: bool,
#[serde(rename = "isScreenUnlocked")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub is_screen_unlocked: bool,
}
impl<'de> serde::Deserialize<'de> for SetIdleOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetIdleOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "isUserActive")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub is_user_active: bool,
#[serde(rename = "isScreenUnlocked")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub is_screen_unlocked: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetIdleOverrideParams {
is_user_active: fields.is_user_active,
is_screen_unlocked: fields.is_screen_unlocked,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetIdleOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetIdleOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetIdleOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetIdleOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetIdleOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetIdleOverride {
type Params = SetIdleOverrideParams;
type Response = SetIdleOverrideResponse;
const METHOD: &'static str = "Emulation.setIdleOverride";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct SetLocaleOverrideParams {
#[serde(rename = "locale")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub locale: Option<String>,
}
impl<'de> serde::Deserialize<'de> for SetLocaleOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetLocaleOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "locale")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub locale: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetLocaleOverrideParams {
locale: fields.locale,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetLocaleOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetLocaleOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetLocaleOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetLocaleOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetLocaleOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetLocaleOverride {
type Params = SetLocaleOverrideParams;
type Response = SetLocaleOverrideResponse;
const METHOD: &'static str = "Emulation.setLocaleOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetNavigatorOverridesParams {
#[serde(rename = "platform")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub platform: String,
}
impl<'de> serde::Deserialize<'de> for SetNavigatorOverridesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetNavigatorOverridesParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "platform")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub platform: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetNavigatorOverridesParams {
platform: fields.platform,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetNavigatorOverrides;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetNavigatorOverridesResponse {}
impl<'de> serde::Deserialize<'de> for SetNavigatorOverridesResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetNavigatorOverridesResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetNavigatorOverridesResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetNavigatorOverrides {
type Params = SetNavigatorOverridesParams;
type Response = SetNavigatorOverridesResponse;
const METHOD: &'static str = "Emulation.setNavigatorOverrides";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPageScaleFactorParams {
#[serde(rename = "pageScaleFactor")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub page_scale_factor: ydp_core::FiniteF64,
}
impl<'de> serde::Deserialize<'de> for SetPageScaleFactorParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPageScaleFactorParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "pageScaleFactor")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub page_scale_factor: ydp_core::FiniteF64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetPageScaleFactorParams {
page_scale_factor: fields.page_scale_factor,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetPageScaleFactor;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPageScaleFactorResponse {}
impl<'de> serde::Deserialize<'de> for SetPageScaleFactorResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPageScaleFactorResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetPageScaleFactorResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetPageScaleFactor {
type Params = SetPageScaleFactorParams;
type Response = SetPageScaleFactorResponse;
const METHOD: &'static str = "Emulation.setPageScaleFactor";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPressureSourceOverrideEnabledParams {
#[serde(rename = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
#[serde(rename = "source")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source: crate::emulation::types::PressureSource,
#[serde(rename = "metadata")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub metadata: Option<crate::emulation::types::PressureMetadata>,
}
impl<'de> serde::Deserialize<'de> for SetPressureSourceOverrideEnabledParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPressureSourceOverrideEnabledParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "source")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source: crate::emulation::types::PressureSource,
#[serde(rename = "metadata")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub metadata: Option<crate::emulation::types::PressureMetadata>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetPressureSourceOverrideEnabledParams {
enabled: fields.enabled,
source: fields.source,
metadata: fields.metadata,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetPressureSourceOverrideEnabled;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPressureSourceOverrideEnabledResponse {}
impl<'de> serde::Deserialize<'de> for SetPressureSourceOverrideEnabledResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPressureSourceOverrideEnabledResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetPressureSourceOverrideEnabledResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetPressureSourceOverrideEnabled {
type Params = SetPressureSourceOverrideEnabledParams;
type Response = SetPressureSourceOverrideEnabledResponse;
const METHOD: &'static str = "Emulation.setPressureSourceOverrideEnabled";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPressureStateOverrideParams {
#[serde(rename = "source")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source: crate::emulation::types::PressureSource,
#[serde(rename = "state")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub state: crate::emulation::types::PressureState,
}
impl<'de> serde::Deserialize<'de> for SetPressureStateOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPressureStateOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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: crate::emulation::types::PressureSource,
#[serde(rename = "state")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub state: crate::emulation::types::PressureState,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetPressureStateOverrideParams {
source: fields.source,
state: fields.state,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetPressureStateOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPressureStateOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetPressureStateOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPressureStateOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetPressureStateOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetPressureStateOverride {
type Params = SetPressureStateOverrideParams;
type Response = SetPressureStateOverrideResponse;
const METHOD: &'static str = "Emulation.setPressureStateOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPrimaryScreenParams {
#[serde(rename = "screenId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub screen_id: crate::emulation::types::ScreenId,
}
impl<'de> serde::Deserialize<'de> for SetPrimaryScreenParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPrimaryScreenParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "screenId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub screen_id: crate::emulation::types::ScreenId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetPrimaryScreenParams {
screen_id: fields.screen_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetPrimaryScreen;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetPrimaryScreenResponse {}
impl<'de> serde::Deserialize<'de> for SetPrimaryScreenResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetPrimaryScreenResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetPrimaryScreenResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetPrimaryScreen {
type Params = SetPrimaryScreenParams;
type Response = SetPrimaryScreenResponse;
const METHOD: &'static str = "Emulation.setPrimaryScreen";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetSafeAreaInsetsOverrideParams {
#[serde(rename = "insets")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub insets: crate::emulation::types::SafeAreaInsets,
}
impl<'de> serde::Deserialize<'de> for SetSafeAreaInsetsOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetSafeAreaInsetsOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "insets")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub insets: crate::emulation::types::SafeAreaInsets,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetSafeAreaInsetsOverrideParams {
insets: fields.insets,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetSafeAreaInsetsOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetSafeAreaInsetsOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetSafeAreaInsetsOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetSafeAreaInsetsOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetSafeAreaInsetsOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetSafeAreaInsetsOverride {
type Params = SetSafeAreaInsetsOverrideParams;
type Response = SetSafeAreaInsetsOverrideResponse;
const METHOD: &'static str = "Emulation.setSafeAreaInsetsOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetScriptExecutionDisabledParams {
#[serde(rename = "value")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub value: bool,
}
impl<'de> serde::Deserialize<'de> for SetScriptExecutionDisabledParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetScriptExecutionDisabledParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "value")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub value: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetScriptExecutionDisabledParams {
value: fields.value,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetScriptExecutionDisabled;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetScriptExecutionDisabledResponse {}
impl<'de> serde::Deserialize<'de> for SetScriptExecutionDisabledResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetScriptExecutionDisabledResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetScriptExecutionDisabledResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetScriptExecutionDisabled {
type Params = SetScriptExecutionDisabledParams;
type Response = SetScriptExecutionDisabledResponse;
const METHOD: &'static str = "Emulation.setScriptExecutionDisabled";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetScrollbarsHiddenParams {
#[serde(rename = "hidden")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub hidden: bool,
}
impl<'de> serde::Deserialize<'de> for SetScrollbarsHiddenParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetScrollbarsHiddenParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "hidden")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub hidden: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetScrollbarsHiddenParams {
hidden: fields.hidden,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetScrollbarsHidden;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetScrollbarsHiddenResponse {}
impl<'de> serde::Deserialize<'de> for SetScrollbarsHiddenResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetScrollbarsHiddenResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetScrollbarsHiddenResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetScrollbarsHidden {
type Params = SetScrollbarsHiddenParams;
type Response = SetScrollbarsHiddenResponse;
const METHOD: &'static str = "Emulation.setScrollbarsHidden";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetSensorOverrideEnabledParams {
#[serde(rename = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::emulation::types::SensorType,
#[serde(rename = "metadata")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub metadata: Option<crate::emulation::types::SensorMetadata>,
}
impl<'de> serde::Deserialize<'de> for SetSensorOverrideEnabledParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetSensorOverrideEnabledParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::emulation::types::SensorType,
#[serde(rename = "metadata")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub metadata: Option<crate::emulation::types::SensorMetadata>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetSensorOverrideEnabledParams {
enabled: fields.enabled,
r#type: fields.r#type,
metadata: fields.metadata,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetSensorOverrideEnabled;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetSensorOverrideEnabledResponse {}
impl<'de> serde::Deserialize<'de> for SetSensorOverrideEnabledResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetSensorOverrideEnabledResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetSensorOverrideEnabledResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetSensorOverrideEnabled {
type Params = SetSensorOverrideEnabledParams;
type Response = SetSensorOverrideEnabledResponse;
const METHOD: &'static str = "Emulation.setSensorOverrideEnabled";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetSensorOverrideReadingsParams {
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::emulation::types::SensorType,
#[serde(rename = "reading")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub reading: crate::emulation::types::SensorReading,
}
impl<'de> serde::Deserialize<'de> for SetSensorOverrideReadingsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetSensorOverrideReadingsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::emulation::types::SensorType,
#[serde(rename = "reading")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub reading: crate::emulation::types::SensorReading,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetSensorOverrideReadingsParams {
r#type: fields.r#type,
reading: fields.reading,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetSensorOverrideReadings;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetSensorOverrideReadingsResponse {}
impl<'de> serde::Deserialize<'de> for SetSensorOverrideReadingsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetSensorOverrideReadingsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetSensorOverrideReadingsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetSensorOverrideReadings {
type Params = SetSensorOverrideReadingsParams;
type Response = SetSensorOverrideReadingsResponse;
const METHOD: &'static str = "Emulation.setSensorOverrideReadings";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetSmallViewportHeightDifferenceOverrideParams {
#[serde(rename = "difference")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub difference: i64,
}
impl<'de> serde::Deserialize<'de> for SetSmallViewportHeightDifferenceOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetSmallViewportHeightDifferenceOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "difference")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub difference: i64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetSmallViewportHeightDifferenceOverrideParams {
difference: fields.difference,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetSmallViewportHeightDifferenceOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetSmallViewportHeightDifferenceOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetSmallViewportHeightDifferenceOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetSmallViewportHeightDifferenceOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetSmallViewportHeightDifferenceOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetSmallViewportHeightDifferenceOverride {
type Params = SetSmallViewportHeightDifferenceOverrideParams;
type Response = SetSmallViewportHeightDifferenceOverrideResponse;
const METHOD: &'static str = "Emulation.setSmallViewportHeightDifferenceOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetTimezoneOverrideParams {
#[serde(rename = "timezoneId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timezone_id: String,
}
impl<'de> serde::Deserialize<'de> for SetTimezoneOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetTimezoneOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "timezoneId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timezone_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetTimezoneOverrideParams {
timezone_id: fields.timezone_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetTimezoneOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetTimezoneOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetTimezoneOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetTimezoneOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetTimezoneOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetTimezoneOverride {
type Params = SetTimezoneOverrideParams;
type Response = SetTimezoneOverrideResponse;
const METHOD: &'static str = "Emulation.setTimezoneOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetTouchEmulationEnabledParams {
#[serde(rename = "enabled")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enabled: bool,
#[serde(rename = "maxTouchPoints")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub max_touch_points: Option<i64>,
}
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 = "maxTouchPoints")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub max_touch_points: Option<i64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetTouchEmulationEnabledParams {
enabled: fields.enabled,
max_touch_points: fields.max_touch_points,
})
}
}
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 = "Emulation.setTouchEmulationEnabled";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetUserAgentOverrideParams {
#[serde(rename = "userAgent")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub user_agent: String,
#[serde(rename = "acceptLanguage")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub accept_language: Option<String>,
#[serde(rename = "platform")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub platform: Option<String>,
#[serde(rename = "userAgentMetadata")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub user_agent_metadata: Option<crate::emulation::types::UserAgentMetadata>,
}
impl<'de> serde::Deserialize<'de> for SetUserAgentOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetUserAgentOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "userAgent")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub user_agent: String,
#[serde(rename = "acceptLanguage")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub accept_language: Option<String>,
#[serde(rename = "platform")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub platform: Option<String>,
#[serde(rename = "userAgentMetadata")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub user_agent_metadata: Option<crate::emulation::types::UserAgentMetadata>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetUserAgentOverrideParams {
user_agent: fields.user_agent,
accept_language: fields.accept_language,
platform: fields.platform,
user_agent_metadata: fields.user_agent_metadata,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetUserAgentOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetUserAgentOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetUserAgentOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetUserAgentOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetUserAgentOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetUserAgentOverride {
type Params = SetUserAgentOverrideParams;
type Response = SetUserAgentOverrideResponse;
const METHOD: &'static str = "Emulation.setUserAgentOverride";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct SetVirtualKeyboardGeometryOverrideParams {
#[serde(rename = "keyboardRect")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub keyboard_rect: Option<crate::dom::types::Rect>,
}
impl<'de> serde::Deserialize<'de> for SetVirtualKeyboardGeometryOverrideParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetVirtualKeyboardGeometryOverrideParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "keyboardRect")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub keyboard_rect: Option<crate::dom::types::Rect>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetVirtualKeyboardGeometryOverrideParams {
keyboard_rect: fields.keyboard_rect,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetVirtualKeyboardGeometryOverride;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetVirtualKeyboardGeometryOverrideResponse {}
impl<'de> serde::Deserialize<'de> for SetVirtualKeyboardGeometryOverrideResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetVirtualKeyboardGeometryOverrideResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetVirtualKeyboardGeometryOverrideResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetVirtualKeyboardGeometryOverride {
type Params = SetVirtualKeyboardGeometryOverrideParams;
type Response = SetVirtualKeyboardGeometryOverrideResponse;
const METHOD: &'static str = "Emulation.setVirtualKeyboardGeometryOverride";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetVirtualTimePolicyParams {
#[serde(rename = "policy")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub policy: crate::emulation::types::VirtualTimePolicy,
#[serde(rename = "budget")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub budget: Option<ydp_core::FiniteF64>,
#[serde(rename = "maxVirtualTimeTaskStarvationCount")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub max_virtual_time_task_starvation_count: Option<i64>,
#[serde(rename = "initialVirtualTime")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub initial_virtual_time: Option<crate::network::types::TimeSinceEpoch>,
}
impl<'de> serde::Deserialize<'de> for SetVirtualTimePolicyParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetVirtualTimePolicyParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "policy")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub policy: crate::emulation::types::VirtualTimePolicy,
#[serde(rename = "budget")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub budget: Option<ydp_core::FiniteF64>,
#[serde(rename = "maxVirtualTimeTaskStarvationCount")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub max_virtual_time_task_starvation_count: Option<i64>,
#[serde(rename = "initialVirtualTime")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub initial_virtual_time: Option<crate::network::types::TimeSinceEpoch>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetVirtualTimePolicyParams {
policy: fields.policy,
budget: fields.budget,
max_virtual_time_task_starvation_count: fields
.max_virtual_time_task_starvation_count,
initial_virtual_time: fields.initial_virtual_time,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetVirtualTimePolicy;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetVirtualTimePolicyResponse {
#[serde(rename = "virtualTimeTicksBase")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub virtual_time_ticks_base: ydp_core::FiniteF64,
}
impl<'de> serde::Deserialize<'de> for SetVirtualTimePolicyResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetVirtualTimePolicyResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "virtualTimeTicksBase")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub virtual_time_ticks_base: ydp_core::FiniteF64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetVirtualTimePolicyResponse {
virtual_time_ticks_base: fields.virtual_time_ticks_base,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetVirtualTimePolicy {
type Params = SetVirtualTimePolicyParams;
type Response = SetVirtualTimePolicyResponse;
const METHOD: &'static str = "Emulation.setVirtualTimePolicy";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetVisibleSizeParams {
#[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,
}
impl<'de> serde::Deserialize<'de> for SetVisibleSizeParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetVisibleSizeParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetVisibleSizeParams {
width: fields.width,
height: fields.height,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetVisibleSize;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetVisibleSizeResponse {}
impl<'de> serde::Deserialize<'de> for SetVisibleSizeResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetVisibleSizeResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetVisibleSizeResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetVisibleSize {
type Params = SetVisibleSizeParams;
type Response = SetVisibleSizeResponse;
const METHOD: &'static str = "Emulation.setVisibleSize";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct UpdateScreenParams {
#[serde(rename = "screenId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub screen_id: crate::emulation::types::ScreenId,
#[serde(rename = "left")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub left: Option<i64>,
#[serde(rename = "top")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub top: Option<i64>,
#[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>,
#[serde(rename = "workAreaInsets")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub work_area_insets: Option<crate::emulation::types::WorkAreaInsets>,
#[serde(rename = "devicePixelRatio")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub device_pixel_ratio: Option<ydp_core::FiniteF64>,
#[serde(rename = "rotation")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub rotation: Option<i64>,
#[serde(rename = "colorDepth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub color_depth: Option<i64>,
#[serde(rename = "label")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub label: Option<String>,
#[serde(rename = "isInternal")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub is_internal: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for UpdateScreenParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UpdateScreenParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "screenId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub screen_id: crate::emulation::types::ScreenId,
#[serde(rename = "left")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub left: Option<i64>,
#[serde(rename = "top")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub top: Option<i64>,
#[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>,
#[serde(rename = "workAreaInsets")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub work_area_insets: Option<crate::emulation::types::WorkAreaInsets>,
#[serde(rename = "devicePixelRatio")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub device_pixel_ratio: Option<ydp_core::FiniteF64>,
#[serde(rename = "rotation")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub rotation: Option<i64>,
#[serde(rename = "colorDepth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub color_depth: Option<i64>,
#[serde(rename = "label")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub label: Option<String>,
#[serde(rename = "isInternal")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub is_internal: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(UpdateScreenParams {
screen_id: fields.screen_id,
left: fields.left,
top: fields.top,
width: fields.width,
height: fields.height,
work_area_insets: fields.work_area_insets,
device_pixel_ratio: fields.device_pixel_ratio,
rotation: fields.rotation,
color_depth: fields.color_depth,
label: fields.label,
is_internal: fields.is_internal,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct UpdateScreen;
#[derive(Debug, Clone, serde::Serialize)]
pub struct UpdateScreenResponse {
#[serde(rename = "screenInfo")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub screen_info: crate::emulation::types::ScreenInfo,
}
impl<'de> serde::Deserialize<'de> for UpdateScreenResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UpdateScreenResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "screenInfo")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub screen_info: crate::emulation::types::ScreenInfo,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(UpdateScreenResponse {
screen_info: fields.screen_info,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for UpdateScreen {
type Params = UpdateScreenParams;
type Response = UpdateScreenResponse;
const METHOD: &'static str = "Emulation.updateScreen";
}