#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearStorageItemsParams {
#[serde(rename = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
#[serde(rename = "storageArea")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_area: crate::extensions::types::StorageArea,
}
impl<'de> serde::Deserialize<'de> for ClearStorageItemsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearStorageItemsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
#[serde(rename = "storageArea")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_area: crate::extensions::types::StorageArea,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ClearStorageItemsParams {
id: fields.id,
storage_area: fields.storage_area,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ClearStorageItems;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearStorageItemsResponse {}
impl<'de> serde::Deserialize<'de> for ClearStorageItemsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearStorageItemsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ClearStorageItemsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ClearStorageItems {
type Params = ClearStorageItemsParams;
type Response = ClearStorageItemsResponse;
const METHOD: &'static str = "Extensions.clearStorageItems";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetExtensionsParams {}
impl<'de> serde::Deserialize<'de> for GetExtensionsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetExtensionsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(GetExtensionsParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetExtensions;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetExtensionsResponse {
#[serde(rename = "extensions")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub extensions: Vec<crate::extensions::types::ExtensionInfo>,
}
impl<'de> serde::Deserialize<'de> for GetExtensionsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetExtensionsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "extensions")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub extensions: Vec<crate::extensions::types::ExtensionInfo>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetExtensionsResponse {
extensions: fields.extensions,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetExtensions {
type Params = GetExtensionsParams;
type Response = GetExtensionsResponse;
const METHOD: &'static str = "Extensions.getExtensions";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetStorageItemsParams {
#[serde(rename = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
#[serde(rename = "storageArea")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_area: crate::extensions::types::StorageArea,
#[serde(rename = "keys")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub keys: Option<Vec<String>>,
}
impl<'de> serde::Deserialize<'de> for GetStorageItemsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetStorageItemsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
#[serde(rename = "storageArea")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_area: crate::extensions::types::StorageArea,
#[serde(rename = "keys")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub keys: Option<Vec<String>>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetStorageItemsParams {
id: fields.id,
storage_area: fields.storage_area,
keys: fields.keys,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetStorageItems;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetStorageItemsResponse {
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: std::collections::BTreeMap<String, serde_json::Value>,
}
impl<'de> serde::Deserialize<'de> for GetStorageItemsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetStorageItemsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: std::collections::BTreeMap<String, serde_json::Value>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetStorageItemsResponse { data: fields.data })
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetStorageItems {
type Params = GetStorageItemsParams;
type Response = GetStorageItemsResponse;
const METHOD: &'static str = "Extensions.getStorageItems";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct LoadUnpackedParams {
#[serde(rename = "path")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub path: String,
#[serde(rename = "enableInIncognito")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub enable_in_incognito: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for LoadUnpackedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = LoadUnpackedParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "path")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub path: String,
#[serde(rename = "enableInIncognito")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub enable_in_incognito: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(LoadUnpackedParams {
path: fields.path,
enable_in_incognito: fields.enable_in_incognito,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct LoadUnpacked;
#[derive(Debug, Clone, serde::Serialize)]
pub struct LoadUnpackedResponse {
#[serde(rename = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
}
impl<'de> serde::Deserialize<'de> for LoadUnpackedResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = LoadUnpackedResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(LoadUnpackedResponse { id: fields.id })
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for LoadUnpacked {
type Params = LoadUnpackedParams;
type Response = LoadUnpackedResponse;
const METHOD: &'static str = "Extensions.loadUnpacked";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveStorageItemsParams {
#[serde(rename = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
#[serde(rename = "storageArea")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_area: crate::extensions::types::StorageArea,
#[serde(rename = "keys")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub keys: Vec<String>,
}
impl<'de> serde::Deserialize<'de> for RemoveStorageItemsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveStorageItemsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
#[serde(rename = "storageArea")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_area: crate::extensions::types::StorageArea,
#[serde(rename = "keys")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub keys: Vec<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RemoveStorageItemsParams {
id: fields.id,
storage_area: fields.storage_area,
keys: fields.keys,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RemoveStorageItems;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveStorageItemsResponse {}
impl<'de> serde::Deserialize<'de> for RemoveStorageItemsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveStorageItemsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(RemoveStorageItemsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RemoveStorageItems {
type Params = RemoveStorageItemsParams;
type Response = RemoveStorageItemsResponse;
const METHOD: &'static str = "Extensions.removeStorageItems";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetStorageItemsParams {
#[serde(rename = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
#[serde(rename = "storageArea")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_area: crate::extensions::types::StorageArea,
#[serde(rename = "values")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub values: std::collections::BTreeMap<String, serde_json::Value>,
}
impl<'de> serde::Deserialize<'de> for SetStorageItemsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetStorageItemsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
#[serde(rename = "storageArea")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_area: crate::extensions::types::StorageArea,
#[serde(rename = "values")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub values: std::collections::BTreeMap<String, serde_json::Value>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetStorageItemsParams {
id: fields.id,
storage_area: fields.storage_area,
values: fields.values,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetStorageItems;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetStorageItemsResponse {}
impl<'de> serde::Deserialize<'de> for SetStorageItemsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetStorageItemsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetStorageItemsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetStorageItems {
type Params = SetStorageItemsParams;
type Response = SetStorageItemsResponse;
const METHOD: &'static str = "Extensions.setStorageItems";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct TriggerActionParams {
#[serde(rename = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
#[serde(rename = "targetId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub target_id: String,
}
impl<'de> serde::Deserialize<'de> for TriggerActionParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TriggerActionParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
#[serde(rename = "targetId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub target_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(TriggerActionParams {
id: fields.id,
target_id: fields.target_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct TriggerAction;
#[derive(Debug, Clone, serde::Serialize)]
pub struct TriggerActionResponse {}
impl<'de> serde::Deserialize<'de> for TriggerActionResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TriggerActionResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(TriggerActionResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for TriggerAction {
type Params = TriggerActionParams;
type Response = TriggerActionResponse;
const METHOD: &'static str = "Extensions.triggerAction";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct UninstallParams {
#[serde(rename = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub 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 = "id")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(UninstallParams { id: fields.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 = "Extensions.uninstall";
}