#[derive(Debug, Clone, serde::Serialize)]
pub struct DeleteCacheParams {
#[serde(rename = "cacheId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cache_id: crate::cache_storage::types::CacheId,
}
impl<'de> serde::Deserialize<'de> for DeleteCacheParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DeleteCacheParams;
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 = "cacheId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cache_id: crate::cache_storage::types::CacheId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DeleteCacheParams {
cache_id: fields.cache_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DeleteCache;
#[derive(Debug, Clone, serde::Serialize)]
pub struct DeleteCacheResponse {}
impl<'de> serde::Deserialize<'de> for DeleteCacheResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DeleteCacheResponse;
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(DeleteCacheResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for DeleteCache {
type Params = DeleteCacheParams;
type Response = DeleteCacheResponse;
const METHOD: &'static str = "CacheStorage.deleteCache";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DeleteEntryParams {
#[serde(rename = "cacheId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cache_id: crate::cache_storage::types::CacheId,
#[serde(rename = "request")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request: String,
}
impl<'de> serde::Deserialize<'de> for DeleteEntryParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DeleteEntryParams;
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 = "cacheId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cache_id: crate::cache_storage::types::CacheId,
#[serde(rename = "request")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DeleteEntryParams {
cache_id: fields.cache_id,
request: fields.request,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DeleteEntry;
#[derive(Debug, Clone, serde::Serialize)]
pub struct DeleteEntryResponse {}
impl<'de> serde::Deserialize<'de> for DeleteEntryResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DeleteEntryResponse;
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(DeleteEntryResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for DeleteEntry {
type Params = DeleteEntryParams;
type Response = DeleteEntryResponse;
const METHOD: &'static str = "CacheStorage.deleteEntry";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct RequestCacheNamesParams {
#[serde(rename = "securityOrigin")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub security_origin: Option<String>,
#[serde(rename = "storageKey")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub storage_key: Option<String>,
#[serde(rename = "storageBucket")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub storage_bucket: Option<crate::storage::types::StorageBucket>,
}
impl<'de> serde::Deserialize<'de> for RequestCacheNamesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RequestCacheNamesParams;
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 = "securityOrigin")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub security_origin: Option<String>,
#[serde(rename = "storageKey")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub storage_key: Option<String>,
#[serde(rename = "storageBucket")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub storage_bucket: Option<crate::storage::types::StorageBucket>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RequestCacheNamesParams {
security_origin: fields.security_origin,
storage_key: fields.storage_key,
storage_bucket: fields.storage_bucket,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RequestCacheNames;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RequestCacheNamesResponse {
#[serde(rename = "caches")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub caches: Vec<crate::cache_storage::types::Cache>,
}
impl<'de> serde::Deserialize<'de> for RequestCacheNamesResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RequestCacheNamesResponse;
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 = "caches")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub caches: Vec<crate::cache_storage::types::Cache>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RequestCacheNamesResponse {
caches: fields.caches,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RequestCacheNames {
type Params = RequestCacheNamesParams;
type Response = RequestCacheNamesResponse;
const METHOD: &'static str = "CacheStorage.requestCacheNames";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RequestCachedResponseParams {
#[serde(rename = "cacheId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cache_id: crate::cache_storage::types::CacheId,
#[serde(rename = "requestURL")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_url: String,
#[serde(rename = "requestHeaders")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_headers: Vec<crate::cache_storage::types::Header>,
}
impl<'de> serde::Deserialize<'de> for RequestCachedResponseParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RequestCachedResponseParams;
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 = "cacheId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cache_id: crate::cache_storage::types::CacheId,
#[serde(rename = "requestURL")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_url: String,
#[serde(rename = "requestHeaders")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub request_headers: Vec<crate::cache_storage::types::Header>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RequestCachedResponseParams {
cache_id: fields.cache_id,
request_url: fields.request_url,
request_headers: fields.request_headers,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RequestCachedResponse;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RequestCachedResponseResponse {
#[serde(rename = "response")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub response: crate::cache_storage::types::CachedResponse,
}
impl<'de> serde::Deserialize<'de> for RequestCachedResponseResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RequestCachedResponseResponse;
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 = "response")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub response: crate::cache_storage::types::CachedResponse,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RequestCachedResponseResponse {
response: fields.response,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RequestCachedResponse {
type Params = RequestCachedResponseParams;
type Response = RequestCachedResponseResponse;
const METHOD: &'static str = "CacheStorage.requestCachedResponse";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RequestEntriesParams {
#[serde(rename = "cacheId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cache_id: crate::cache_storage::types::CacheId,
#[serde(rename = "skipCount")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub skip_count: Option<i64>,
#[serde(rename = "pageSize")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub page_size: Option<i64>,
#[serde(rename = "pathFilter")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub path_filter: Option<String>,
}
impl<'de> serde::Deserialize<'de> for RequestEntriesParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RequestEntriesParams;
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 = "cacheId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cache_id: crate::cache_storage::types::CacheId,
#[serde(rename = "skipCount")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub skip_count: Option<i64>,
#[serde(rename = "pageSize")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub page_size: Option<i64>,
#[serde(rename = "pathFilter")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub path_filter: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RequestEntriesParams {
cache_id: fields.cache_id,
skip_count: fields.skip_count,
page_size: fields.page_size,
path_filter: fields.path_filter,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RequestEntries;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RequestEntriesResponse {
#[serde(rename = "cacheDataEntries")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cache_data_entries: Vec<crate::cache_storage::types::DataEntry>,
#[serde(rename = "returnCount")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub return_count: ydp_core::FiniteF64,
}
impl<'de> serde::Deserialize<'de> for RequestEntriesResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RequestEntriesResponse;
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 = "cacheDataEntries")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cache_data_entries: Vec<crate::cache_storage::types::DataEntry>,
#[serde(rename = "returnCount")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub return_count: ydp_core::FiniteF64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RequestEntriesResponse {
cache_data_entries: fields.cache_data_entries,
return_count: fields.return_count,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RequestEntries {
type Params = RequestEntriesParams;
type Response = RequestEntriesResponse;
const METHOD: &'static str = "CacheStorage.requestEntries";
}