#[derive(Debug, Clone, serde::Serialize)]
pub struct ChangeAppUserSettingsParams {
#[serde(rename = "manifestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest_id: String,
#[serde(rename = "linkCapturing")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub link_capturing: Option<bool>,
#[serde(rename = "displayMode")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub display_mode: Option<crate::pwa::types::DisplayMode>,
}
impl<'de> serde::Deserialize<'de> for ChangeAppUserSettingsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ChangeAppUserSettingsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "manifestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest_id: String,
#[serde(rename = "linkCapturing")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub link_capturing: Option<bool>,
#[serde(rename = "displayMode")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub display_mode: Option<crate::pwa::types::DisplayMode>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ChangeAppUserSettingsParams {
manifest_id: fields.manifest_id,
link_capturing: fields.link_capturing,
display_mode: fields.display_mode,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ChangeAppUserSettings;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ChangeAppUserSettingsResponse {}
impl<'de> serde::Deserialize<'de> for ChangeAppUserSettingsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ChangeAppUserSettingsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ChangeAppUserSettingsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ChangeAppUserSettings {
type Params = ChangeAppUserSettingsParams;
type Response = ChangeAppUserSettingsResponse;
const METHOD: &'static str = "PWA.changeAppUserSettings";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetOsAppStateParams {
#[serde(rename = "manifestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest_id: String,
}
impl<'de> serde::Deserialize<'de> for GetOsAppStateParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetOsAppStateParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "manifestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetOsAppStateParams {
manifest_id: fields.manifest_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetOsAppState;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetOsAppStateResponse {
#[serde(rename = "badgeCount")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub badge_count: i64,
#[serde(rename = "fileHandlers")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub file_handlers: Vec<crate::pwa::types::FileHandler>,
}
impl<'de> serde::Deserialize<'de> for GetOsAppStateResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetOsAppStateResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "badgeCount")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub badge_count: i64,
#[serde(rename = "fileHandlers")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub file_handlers: Vec<crate::pwa::types::FileHandler>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetOsAppStateResponse {
badge_count: fields.badge_count,
file_handlers: fields.file_handlers,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetOsAppState {
type Params = GetOsAppStateParams;
type Response = GetOsAppStateResponse;
const METHOD: &'static str = "PWA.getOsAppState";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct InstallParams {
#[serde(rename = "manifestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest_id: String,
#[serde(rename = "installUrlOrBundleUrl")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub install_url_or_bundle_url: Option<String>,
}
impl<'de> serde::Deserialize<'de> for InstallParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = InstallParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "manifestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest_id: String,
#[serde(rename = "installUrlOrBundleUrl")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub install_url_or_bundle_url: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(InstallParams {
manifest_id: fields.manifest_id,
install_url_or_bundle_url: fields.install_url_or_bundle_url,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Install;
#[derive(Debug, Clone, serde::Serialize)]
pub struct InstallResponse {}
impl<'de> serde::Deserialize<'de> for InstallResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = InstallResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(InstallResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Install {
type Params = InstallParams;
type Response = InstallResponse;
const METHOD: &'static str = "PWA.install";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct LaunchParams {
#[serde(rename = "manifestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest_id: String,
#[serde(rename = "url")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub url: Option<String>,
}
impl<'de> serde::Deserialize<'de> for LaunchParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = LaunchParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "manifestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest_id: String,
#[serde(rename = "url")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub url: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(LaunchParams {
manifest_id: fields.manifest_id,
url: fields.url,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Launch;
#[derive(Debug, Clone, serde::Serialize)]
pub struct LaunchResponse {
#[serde(rename = "targetId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub target_id: crate::target::types::TargetId,
}
impl<'de> serde::Deserialize<'de> for LaunchResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = LaunchResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "targetId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub target_id: crate::target::types::TargetId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(LaunchResponse {
target_id: fields.target_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Launch {
type Params = LaunchParams;
type Response = LaunchResponse;
const METHOD: &'static str = "PWA.launch";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct LaunchFilesInAppParams {
#[serde(rename = "manifestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest_id: String,
#[serde(rename = "files")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub files: Vec<String>,
}
impl<'de> serde::Deserialize<'de> for LaunchFilesInAppParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = LaunchFilesInAppParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "manifestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest_id: String,
#[serde(rename = "files")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub files: Vec<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(LaunchFilesInAppParams {
manifest_id: fields.manifest_id,
files: fields.files,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct LaunchFilesInApp;
#[derive(Debug, Clone, serde::Serialize)]
pub struct LaunchFilesInAppResponse {
#[serde(rename = "targetIds")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub target_ids: Vec<crate::target::types::TargetId>,
}
impl<'de> serde::Deserialize<'de> for LaunchFilesInAppResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = LaunchFilesInAppResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "targetIds")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub target_ids: Vec<crate::target::types::TargetId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(LaunchFilesInAppResponse {
target_ids: fields.target_ids,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for LaunchFilesInApp {
type Params = LaunchFilesInAppParams;
type Response = LaunchFilesInAppResponse;
const METHOD: &'static str = "PWA.launchFilesInApp";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct OpenCurrentPageInAppParams {
#[serde(rename = "manifestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest_id: String,
}
impl<'de> serde::Deserialize<'de> for OpenCurrentPageInAppParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = OpenCurrentPageInAppParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "manifestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(OpenCurrentPageInAppParams {
manifest_id: fields.manifest_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct OpenCurrentPageInApp;
#[derive(Debug, Clone, serde::Serialize)]
pub struct OpenCurrentPageInAppResponse {}
impl<'de> serde::Deserialize<'de> for OpenCurrentPageInAppResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = OpenCurrentPageInAppResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(OpenCurrentPageInAppResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for OpenCurrentPageInApp {
type Params = OpenCurrentPageInAppParams;
type Response = OpenCurrentPageInAppResponse;
const METHOD: &'static str = "PWA.openCurrentPageInApp";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct UninstallParams {
#[serde(rename = "manifestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest_id: String,
}
impl<'de> serde::Deserialize<'de> for UninstallParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UninstallParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "manifestId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manifest_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(UninstallParams {
manifest_id: fields.manifest_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Uninstall;
#[derive(Debug, Clone, serde::Serialize)]
pub struct UninstallResponse {}
impl<'de> serde::Deserialize<'de> for UninstallResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UninstallResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(UninstallResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Uninstall {
type Params = UninstallParams;
type Response = UninstallResponse;
const METHOD: &'static str = "PWA.uninstall";
}