#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct ClearCookiesParams {
#[serde(rename = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
}
impl<'de> serde::Deserialize<'de> for ClearCookiesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearCookiesParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ClearCookiesParams {
browser_context_id: fields.browser_context_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ClearCookies;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearCookiesResponse {}
impl<'de> serde::Deserialize<'de> for ClearCookiesResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearCookiesResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ClearCookiesResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ClearCookies {
type Params = ClearCookiesParams;
type Response = ClearCookiesResponse;
const METHOD: &'static str = "Storage.clearCookies";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearDataForOriginParams {
#[serde(rename = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
#[serde(rename = "storageTypes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_types: String,
}
impl<'de> serde::Deserialize<'de> for ClearDataForOriginParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearDataForOriginParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
#[serde(rename = "storageTypes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_types: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ClearDataForOriginParams {
origin: fields.origin,
storage_types: fields.storage_types,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ClearDataForOrigin;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearDataForOriginResponse {}
impl<'de> serde::Deserialize<'de> for ClearDataForOriginResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearDataForOriginResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ClearDataForOriginResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ClearDataForOrigin {
type Params = ClearDataForOriginParams;
type Response = ClearDataForOriginResponse;
const METHOD: &'static str = "Storage.clearDataForOrigin";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearDataForStorageKeyParams {
#[serde(rename = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: String,
#[serde(rename = "storageTypes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_types: String,
}
impl<'de> serde::Deserialize<'de> for ClearDataForStorageKeyParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearDataForStorageKeyParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: String,
#[serde(rename = "storageTypes")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_types: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ClearDataForStorageKeyParams {
storage_key: fields.storage_key,
storage_types: fields.storage_types,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ClearDataForStorageKey;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearDataForStorageKeyResponse {}
impl<'de> serde::Deserialize<'de> for ClearDataForStorageKeyResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearDataForStorageKeyResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(ClearDataForStorageKeyResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ClearDataForStorageKey {
type Params = ClearDataForStorageKeyParams;
type Response = ClearDataForStorageKeyResponse;
const METHOD: &'static str = "Storage.clearDataForStorageKey";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearTrustTokensParams {
#[serde(rename = "issuerOrigin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub issuer_origin: String,
}
impl<'de> serde::Deserialize<'de> for ClearTrustTokensParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearTrustTokensParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "issuerOrigin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub issuer_origin: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ClearTrustTokensParams {
issuer_origin: fields.issuer_origin,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ClearTrustTokens;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ClearTrustTokensResponse {
#[serde(rename = "didDeleteTokens")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub did_delete_tokens: bool,
}
impl<'de> serde::Deserialize<'de> for ClearTrustTokensResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ClearTrustTokensResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "didDeleteTokens")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub did_delete_tokens: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ClearTrustTokensResponse {
did_delete_tokens: fields.did_delete_tokens,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ClearTrustTokens {
type Params = ClearTrustTokensParams;
type Response = ClearTrustTokensResponse;
const METHOD: &'static str = "Storage.clearTrustTokens";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DeleteStorageBucketParams {
#[serde(rename = "bucket")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub bucket: crate::storage::types::StorageBucket,
}
impl<'de> serde::Deserialize<'de> for DeleteStorageBucketParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DeleteStorageBucketParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "bucket")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub bucket: crate::storage::types::StorageBucket,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DeleteStorageBucketParams {
bucket: fields.bucket,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DeleteStorageBucket;
#[derive(Debug, Clone, serde::Serialize)]
pub struct DeleteStorageBucketResponse {}
impl<'de> serde::Deserialize<'de> for DeleteStorageBucketResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DeleteStorageBucketResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(DeleteStorageBucketResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for DeleteStorageBucket {
type Params = DeleteStorageBucketParams;
type Response = DeleteStorageBucketResponse;
const METHOD: &'static str = "Storage.deleteStorageBucket";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetCookiesParams {
#[serde(rename = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
}
impl<'de> serde::Deserialize<'de> for GetCookiesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetCookiesParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetCookiesParams {
browser_context_id: fields.browser_context_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetCookies;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetCookiesResponse {
#[serde(rename = "cookies")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cookies: Vec<crate::network::types::Cookie>,
}
impl<'de> serde::Deserialize<'de> for GetCookiesResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetCookiesResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "cookies")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cookies: Vec<crate::network::types::Cookie>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetCookiesResponse {
cookies: fields.cookies,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetCookies {
type Params = GetCookiesParams;
type Response = GetCookiesResponse;
const METHOD: &'static str = "Storage.getCookies";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetRelatedWebsiteSetsParams {}
impl<'de> serde::Deserialize<'de> for GetRelatedWebsiteSetsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetRelatedWebsiteSetsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(GetRelatedWebsiteSetsParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetRelatedWebsiteSets;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetRelatedWebsiteSetsResponse {
#[serde(rename = "sets")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub sets: Vec<crate::storage::types::RelatedWebsiteSet>,
}
impl<'de> serde::Deserialize<'de> for GetRelatedWebsiteSetsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetRelatedWebsiteSetsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "sets")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub sets: Vec<crate::storage::types::RelatedWebsiteSet>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetRelatedWebsiteSetsResponse { sets: fields.sets })
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetRelatedWebsiteSets {
type Params = GetRelatedWebsiteSetsParams;
type Response = GetRelatedWebsiteSetsResponse;
const METHOD: &'static str = "Storage.getRelatedWebsiteSets";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetStorageKeyParams {
#[serde(rename = "frameId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub frame_id: Option<crate::page::types::FrameId>,
}
impl<'de> serde::Deserialize<'de> for GetStorageKeyParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetStorageKeyParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "frameId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub frame_id: Option<crate::page::types::FrameId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetStorageKeyParams {
frame_id: fields.frame_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetStorageKey;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetStorageKeyResponse {
#[serde(rename = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: crate::storage::types::SerializedStorageKey,
}
impl<'de> serde::Deserialize<'de> for GetStorageKeyResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetStorageKeyResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: crate::storage::types::SerializedStorageKey,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetStorageKeyResponse {
storage_key: fields.storage_key,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetStorageKey {
type Params = GetStorageKeyParams;
type Response = GetStorageKeyResponse;
const METHOD: &'static str = "Storage.getStorageKey";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetStorageKeyForFrameParams {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
impl<'de> serde::Deserialize<'de> for GetStorageKeyForFrameParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetStorageKeyForFrameParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "frameId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub frame_id: crate::page::types::FrameId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetStorageKeyForFrameParams {
frame_id: fields.frame_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetStorageKeyForFrame;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetStorageKeyForFrameResponse {
#[serde(rename = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: crate::storage::types::SerializedStorageKey,
}
impl<'de> serde::Deserialize<'de> for GetStorageKeyForFrameResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetStorageKeyForFrameResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: crate::storage::types::SerializedStorageKey,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetStorageKeyForFrameResponse {
storage_key: fields.storage_key,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetStorageKeyForFrame {
type Params = GetStorageKeyForFrameParams;
type Response = GetStorageKeyForFrameResponse;
const METHOD: &'static str = "Storage.getStorageKeyForFrame";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetTrustTokensParams {}
impl<'de> serde::Deserialize<'de> for GetTrustTokensParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetTrustTokensParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(GetTrustTokensParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetTrustTokens;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetTrustTokensResponse {
#[serde(rename = "tokens")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub tokens: Vec<crate::storage::types::TrustTokens>,
}
impl<'de> serde::Deserialize<'de> for GetTrustTokensResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetTrustTokensResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "tokens")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub tokens: Vec<crate::storage::types::TrustTokens>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetTrustTokensResponse {
tokens: fields.tokens,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetTrustTokens {
type Params = GetTrustTokensParams;
type Response = GetTrustTokensResponse;
const METHOD: &'static str = "Storage.getTrustTokens";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetUsageAndQuotaParams {
#[serde(rename = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
}
impl<'de> serde::Deserialize<'de> for GetUsageAndQuotaParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetUsageAndQuotaParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetUsageAndQuotaParams {
origin: fields.origin,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetUsageAndQuota;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetUsageAndQuotaResponse {
#[serde(rename = "usage")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub usage: ydp_core::FiniteF64,
#[serde(rename = "quota")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub quota: ydp_core::FiniteF64,
#[serde(rename = "overrideActive")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub override_active: bool,
#[serde(rename = "usageBreakdown")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub usage_breakdown: Vec<crate::storage::types::UsageForType>,
}
impl<'de> serde::Deserialize<'de> for GetUsageAndQuotaResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetUsageAndQuotaResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "usage")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub usage: ydp_core::FiniteF64,
#[serde(rename = "quota")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub quota: ydp_core::FiniteF64,
#[serde(rename = "overrideActive")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub override_active: bool,
#[serde(rename = "usageBreakdown")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub usage_breakdown: Vec<crate::storage::types::UsageForType>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetUsageAndQuotaResponse {
usage: fields.usage,
quota: fields.quota,
override_active: fields.override_active,
usage_breakdown: fields.usage_breakdown,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetUsageAndQuota {
type Params = GetUsageAndQuotaParams;
type Response = GetUsageAndQuotaResponse;
const METHOD: &'static str = "Storage.getUsageAndQuota";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct OverrideQuotaForOriginParams {
#[serde(rename = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
#[serde(rename = "quotaSize")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub quota_size: Option<ydp_core::FiniteF64>,
}
impl<'de> serde::Deserialize<'de> for OverrideQuotaForOriginParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = OverrideQuotaForOriginParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
#[serde(rename = "quotaSize")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub quota_size: Option<ydp_core::FiniteF64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(OverrideQuotaForOriginParams {
origin: fields.origin,
quota_size: fields.quota_size,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct OverrideQuotaForOrigin;
#[derive(Debug, Clone, serde::Serialize)]
pub struct OverrideQuotaForOriginResponse {}
impl<'de> serde::Deserialize<'de> for OverrideQuotaForOriginResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = OverrideQuotaForOriginResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(OverrideQuotaForOriginResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for OverrideQuotaForOrigin {
type Params = OverrideQuotaForOriginParams;
type Response = OverrideQuotaForOriginResponse;
const METHOD: &'static str = "Storage.overrideQuotaForOrigin";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct RunBounceTrackingMitigationsParams {}
impl<'de> serde::Deserialize<'de> for RunBounceTrackingMitigationsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RunBounceTrackingMitigationsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(RunBounceTrackingMitigationsParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RunBounceTrackingMitigations;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RunBounceTrackingMitigationsResponse {
#[serde(rename = "deletedSites")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub deleted_sites: Vec<String>,
}
impl<'de> serde::Deserialize<'de> for RunBounceTrackingMitigationsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RunBounceTrackingMitigationsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "deletedSites")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub deleted_sites: Vec<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RunBounceTrackingMitigationsResponse {
deleted_sites: fields.deleted_sites,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RunBounceTrackingMitigations {
type Params = RunBounceTrackingMitigationsParams;
type Response = RunBounceTrackingMitigationsResponse;
const METHOD: &'static str = "Storage.runBounceTrackingMitigations";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetCookiesParams {
#[serde(rename = "cookies")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cookies: Vec<crate::network::types::CookieParam>,
#[serde(rename = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
}
impl<'de> serde::Deserialize<'de> for SetCookiesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetCookiesParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "cookies")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cookies: Vec<crate::network::types::CookieParam>,
#[serde(rename = "browserContextId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub browser_context_id: Option<crate::browser::types::BrowserContextId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetCookiesParams {
cookies: fields.cookies,
browser_context_id: fields.browser_context_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetCookies;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetCookiesResponse {}
impl<'de> serde::Deserialize<'de> for SetCookiesResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetCookiesResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetCookiesResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetCookies {
type Params = SetCookiesParams;
type Response = SetCookiesResponse;
const METHOD: &'static str = "Storage.setCookies";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetStorageBucketTrackingParams {
#[serde(rename = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: String,
#[serde(rename = "enable")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enable: bool,
}
impl<'de> serde::Deserialize<'de> for SetStorageBucketTrackingParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetStorageBucketTrackingParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: String,
#[serde(rename = "enable")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub enable: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetStorageBucketTrackingParams {
storage_key: fields.storage_key,
enable: fields.enable,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetStorageBucketTracking;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetStorageBucketTrackingResponse {}
impl<'de> serde::Deserialize<'de> for SetStorageBucketTrackingResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetStorageBucketTrackingResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(SetStorageBucketTrackingResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetStorageBucketTracking {
type Params = SetStorageBucketTrackingParams;
type Response = SetStorageBucketTrackingResponse;
const METHOD: &'static str = "Storage.setStorageBucketTracking";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct TrackCacheStorageForOriginParams {
#[serde(rename = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
}
impl<'de> serde::Deserialize<'de> for TrackCacheStorageForOriginParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TrackCacheStorageForOriginParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(TrackCacheStorageForOriginParams {
origin: fields.origin,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct TrackCacheStorageForOrigin;
#[derive(Debug, Clone, serde::Serialize)]
pub struct TrackCacheStorageForOriginResponse {}
impl<'de> serde::Deserialize<'de> for TrackCacheStorageForOriginResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TrackCacheStorageForOriginResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(TrackCacheStorageForOriginResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for TrackCacheStorageForOrigin {
type Params = TrackCacheStorageForOriginParams;
type Response = TrackCacheStorageForOriginResponse;
const METHOD: &'static str = "Storage.trackCacheStorageForOrigin";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct TrackCacheStorageForStorageKeyParams {
#[serde(rename = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: String,
}
impl<'de> serde::Deserialize<'de> for TrackCacheStorageForStorageKeyParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TrackCacheStorageForStorageKeyParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(TrackCacheStorageForStorageKeyParams {
storage_key: fields.storage_key,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct TrackCacheStorageForStorageKey;
#[derive(Debug, Clone, serde::Serialize)]
pub struct TrackCacheStorageForStorageKeyResponse {}
impl<'de> serde::Deserialize<'de> for TrackCacheStorageForStorageKeyResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TrackCacheStorageForStorageKeyResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(TrackCacheStorageForStorageKeyResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for TrackCacheStorageForStorageKey {
type Params = TrackCacheStorageForStorageKeyParams;
type Response = TrackCacheStorageForStorageKeyResponse;
const METHOD: &'static str = "Storage.trackCacheStorageForStorageKey";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct TrackIndexedDbForOriginParams {
#[serde(rename = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
}
impl<'de> serde::Deserialize<'de> for TrackIndexedDbForOriginParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TrackIndexedDbForOriginParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(TrackIndexedDbForOriginParams {
origin: fields.origin,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct TrackIndexedDbForOrigin;
#[derive(Debug, Clone, serde::Serialize)]
pub struct TrackIndexedDbForOriginResponse {}
impl<'de> serde::Deserialize<'de> for TrackIndexedDbForOriginResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TrackIndexedDbForOriginResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(TrackIndexedDbForOriginResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for TrackIndexedDbForOrigin {
type Params = TrackIndexedDbForOriginParams;
type Response = TrackIndexedDbForOriginResponse;
const METHOD: &'static str = "Storage.trackIndexedDBForOrigin";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct TrackIndexedDbForStorageKeyParams {
#[serde(rename = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: String,
}
impl<'de> serde::Deserialize<'de> for TrackIndexedDbForStorageKeyParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TrackIndexedDbForStorageKeyParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(TrackIndexedDbForStorageKeyParams {
storage_key: fields.storage_key,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct TrackIndexedDbForStorageKey;
#[derive(Debug, Clone, serde::Serialize)]
pub struct TrackIndexedDbForStorageKeyResponse {}
impl<'de> serde::Deserialize<'de> for TrackIndexedDbForStorageKeyResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TrackIndexedDbForStorageKeyResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(TrackIndexedDbForStorageKeyResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for TrackIndexedDbForStorageKey {
type Params = TrackIndexedDbForStorageKeyParams;
type Response = TrackIndexedDbForStorageKeyResponse;
const METHOD: &'static str = "Storage.trackIndexedDBForStorageKey";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct UntrackCacheStorageForOriginParams {
#[serde(rename = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
}
impl<'de> serde::Deserialize<'de> for UntrackCacheStorageForOriginParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UntrackCacheStorageForOriginParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(UntrackCacheStorageForOriginParams {
origin: fields.origin,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct UntrackCacheStorageForOrigin;
#[derive(Debug, Clone, serde::Serialize)]
pub struct UntrackCacheStorageForOriginResponse {}
impl<'de> serde::Deserialize<'de> for UntrackCacheStorageForOriginResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UntrackCacheStorageForOriginResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(UntrackCacheStorageForOriginResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for UntrackCacheStorageForOrigin {
type Params = UntrackCacheStorageForOriginParams;
type Response = UntrackCacheStorageForOriginResponse;
const METHOD: &'static str = "Storage.untrackCacheStorageForOrigin";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct UntrackCacheStorageForStorageKeyParams {
#[serde(rename = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: String,
}
impl<'de> serde::Deserialize<'de> for UntrackCacheStorageForStorageKeyParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UntrackCacheStorageForStorageKeyParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(UntrackCacheStorageForStorageKeyParams {
storage_key: fields.storage_key,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct UntrackCacheStorageForStorageKey;
#[derive(Debug, Clone, serde::Serialize)]
pub struct UntrackCacheStorageForStorageKeyResponse {}
impl<'de> serde::Deserialize<'de> for UntrackCacheStorageForStorageKeyResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UntrackCacheStorageForStorageKeyResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(UntrackCacheStorageForStorageKeyResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for UntrackCacheStorageForStorageKey {
type Params = UntrackCacheStorageForStorageKeyParams;
type Response = UntrackCacheStorageForStorageKeyResponse;
const METHOD: &'static str = "Storage.untrackCacheStorageForStorageKey";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct UntrackIndexedDbForOriginParams {
#[serde(rename = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
}
impl<'de> serde::Deserialize<'de> for UntrackIndexedDbForOriginParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UntrackIndexedDbForOriginParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(UntrackIndexedDbForOriginParams {
origin: fields.origin,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct UntrackIndexedDbForOrigin;
#[derive(Debug, Clone, serde::Serialize)]
pub struct UntrackIndexedDbForOriginResponse {}
impl<'de> serde::Deserialize<'de> for UntrackIndexedDbForOriginResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UntrackIndexedDbForOriginResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(UntrackIndexedDbForOriginResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for UntrackIndexedDbForOrigin {
type Params = UntrackIndexedDbForOriginParams;
type Response = UntrackIndexedDbForOriginResponse;
const METHOD: &'static str = "Storage.untrackIndexedDBForOrigin";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct UntrackIndexedDbForStorageKeyParams {
#[serde(rename = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: String,
}
impl<'de> serde::Deserialize<'de> for UntrackIndexedDbForStorageKeyParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UntrackIndexedDbForStorageKeyParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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 = "storageKey")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub storage_key: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(UntrackIndexedDbForStorageKeyParams {
storage_key: fields.storage_key,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct UntrackIndexedDbForStorageKey;
#[derive(Debug, Clone, serde::Serialize)]
pub struct UntrackIndexedDbForStorageKeyResponse {}
impl<'de> serde::Deserialize<'de> for UntrackIndexedDbForStorageKeyResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UntrackIndexedDbForStorageKeyResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.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(UntrackIndexedDbForStorageKeyResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for UntrackIndexedDbForStorageKey {
type Params = UntrackIndexedDbForStorageKeyParams;
type Response = UntrackIndexedDbForStorageKeyResponse;
const METHOD: &'static str = "Storage.untrackIndexedDBForStorageKey";
}