#[derive(Debug, Clone, serde::Serialize)]
pub struct DeliverPushMessageParams {
#[serde(rename = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
#[serde(rename = "registrationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub registration_id: crate::service_worker::types::RegistrationId,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
}
impl<'de> serde::Deserialize<'de> for DeliverPushMessageParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DeliverPushMessageParams;
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 = "registrationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub registration_id: crate::service_worker::types::RegistrationId,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DeliverPushMessageParams {
origin: fields.origin,
registration_id: fields.registration_id,
data: fields.data,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DeliverPushMessage;
#[derive(Debug, Clone, serde::Serialize)]
pub struct DeliverPushMessageResponse {}
impl<'de> serde::Deserialize<'de> for DeliverPushMessageResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DeliverPushMessageResponse;
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(DeliverPushMessageResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for DeliverPushMessage {
type Params = DeliverPushMessageParams;
type Response = DeliverPushMessageResponse;
const METHOD: &'static str = "ServiceWorker.deliverPushMessage";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct DisableParams {}
impl<'de> serde::Deserialize<'de> for DisableParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DisableParams;
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(DisableParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Disable;
#[derive(Debug, Clone, serde::Serialize)]
pub struct DisableResponse {}
impl<'de> serde::Deserialize<'de> for DisableResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DisableResponse;
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(DisableResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Disable {
type Params = DisableParams;
type Response = DisableResponse;
const METHOD: &'static str = "ServiceWorker.disable";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DispatchPeriodicSyncEventParams {
#[serde(rename = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
#[serde(rename = "registrationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub registration_id: crate::service_worker::types::RegistrationId,
#[serde(rename = "tag")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub tag: String,
}
impl<'de> serde::Deserialize<'de> for DispatchPeriodicSyncEventParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DispatchPeriodicSyncEventParams;
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 = "registrationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub registration_id: crate::service_worker::types::RegistrationId,
#[serde(rename = "tag")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub tag: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DispatchPeriodicSyncEventParams {
origin: fields.origin,
registration_id: fields.registration_id,
tag: fields.tag,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DispatchPeriodicSyncEvent;
#[derive(Debug, Clone, serde::Serialize)]
pub struct DispatchPeriodicSyncEventResponse {}
impl<'de> serde::Deserialize<'de> for DispatchPeriodicSyncEventResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DispatchPeriodicSyncEventResponse;
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(DispatchPeriodicSyncEventResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for DispatchPeriodicSyncEvent {
type Params = DispatchPeriodicSyncEventParams;
type Response = DispatchPeriodicSyncEventResponse;
const METHOD: &'static str = "ServiceWorker.dispatchPeriodicSyncEvent";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct DispatchSyncEventParams {
#[serde(rename = "origin")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub origin: String,
#[serde(rename = "registrationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub registration_id: crate::service_worker::types::RegistrationId,
#[serde(rename = "tag")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub tag: String,
#[serde(rename = "lastChance")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub last_chance: bool,
}
impl<'de> serde::Deserialize<'de> for DispatchSyncEventParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DispatchSyncEventParams;
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 = "registrationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub registration_id: crate::service_worker::types::RegistrationId,
#[serde(rename = "tag")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub tag: String,
#[serde(rename = "lastChance")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub last_chance: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DispatchSyncEventParams {
origin: fields.origin,
registration_id: fields.registration_id,
tag: fields.tag,
last_chance: fields.last_chance,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DispatchSyncEvent;
#[derive(Debug, Clone, serde::Serialize)]
pub struct DispatchSyncEventResponse {}
impl<'de> serde::Deserialize<'de> for DispatchSyncEventResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DispatchSyncEventResponse;
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(DispatchSyncEventResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for DispatchSyncEvent {
type Params = DispatchSyncEventParams;
type Response = DispatchSyncEventResponse;
const METHOD: &'static str = "ServiceWorker.dispatchSyncEvent";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct EnableParams {}
impl<'de> serde::Deserialize<'de> for EnableParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = EnableParams;
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(EnableParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Enable;
#[derive(Debug, Clone, serde::Serialize)]
pub struct EnableResponse {}
impl<'de> serde::Deserialize<'de> for EnableResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = EnableResponse;
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(EnableResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Enable {
type Params = EnableParams;
type Response = EnableResponse;
const METHOD: &'static str = "ServiceWorker.enable";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetForceUpdateOnPageLoadParams {
#[serde(rename = "forceUpdateOnPageLoad")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub force_update_on_page_load: bool,
}
impl<'de> serde::Deserialize<'de> for SetForceUpdateOnPageLoadParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetForceUpdateOnPageLoadParams;
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 = "forceUpdateOnPageLoad")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub force_update_on_page_load: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetForceUpdateOnPageLoadParams {
force_update_on_page_load: fields.force_update_on_page_load,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetForceUpdateOnPageLoad;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetForceUpdateOnPageLoadResponse {}
impl<'de> serde::Deserialize<'de> for SetForceUpdateOnPageLoadResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetForceUpdateOnPageLoadResponse;
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(SetForceUpdateOnPageLoadResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetForceUpdateOnPageLoad {
type Params = SetForceUpdateOnPageLoadParams;
type Response = SetForceUpdateOnPageLoadResponse;
const METHOD: &'static str = "ServiceWorker.setForceUpdateOnPageLoad";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SkipWaitingParams {
#[serde(rename = "scopeURL")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub scope_url: String,
}
impl<'de> serde::Deserialize<'de> for SkipWaitingParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SkipWaitingParams;
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 = "scopeURL")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub scope_url: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SkipWaitingParams {
scope_url: fields.scope_url,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SkipWaiting;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SkipWaitingResponse {}
impl<'de> serde::Deserialize<'de> for SkipWaitingResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SkipWaitingResponse;
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(SkipWaitingResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SkipWaiting {
type Params = SkipWaitingParams;
type Response = SkipWaitingResponse;
const METHOD: &'static str = "ServiceWorker.skipWaiting";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct StartWorkerParams {
#[serde(rename = "scopeURL")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub scope_url: String,
}
impl<'de> serde::Deserialize<'de> for StartWorkerParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StartWorkerParams;
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 = "scopeURL")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub scope_url: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(StartWorkerParams {
scope_url: fields.scope_url,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct StartWorker;
#[derive(Debug, Clone, serde::Serialize)]
pub struct StartWorkerResponse {}
impl<'de> serde::Deserialize<'de> for StartWorkerResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StartWorkerResponse;
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(StartWorkerResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for StartWorker {
type Params = StartWorkerParams;
type Response = StartWorkerResponse;
const METHOD: &'static str = "ServiceWorker.startWorker";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct StopAllWorkersParams {}
impl<'de> serde::Deserialize<'de> for StopAllWorkersParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StopAllWorkersParams;
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(StopAllWorkersParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct StopAllWorkers;
#[derive(Debug, Clone, serde::Serialize)]
pub struct StopAllWorkersResponse {}
impl<'de> serde::Deserialize<'de> for StopAllWorkersResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StopAllWorkersResponse;
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(StopAllWorkersResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for StopAllWorkers {
type Params = StopAllWorkersParams;
type Response = StopAllWorkersResponse;
const METHOD: &'static str = "ServiceWorker.stopAllWorkers";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct StopWorkerParams {
#[serde(rename = "versionId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub version_id: String,
}
impl<'de> serde::Deserialize<'de> for StopWorkerParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StopWorkerParams;
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 = "versionId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub version_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(StopWorkerParams {
version_id: fields.version_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct StopWorker;
#[derive(Debug, Clone, serde::Serialize)]
pub struct StopWorkerResponse {}
impl<'de> serde::Deserialize<'de> for StopWorkerResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StopWorkerResponse;
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(StopWorkerResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for StopWorker {
type Params = StopWorkerParams;
type Response = StopWorkerResponse;
const METHOD: &'static str = "ServiceWorker.stopWorker";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct UnregisterParams {
#[serde(rename = "scopeURL")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub scope_url: String,
}
impl<'de> serde::Deserialize<'de> for UnregisterParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UnregisterParams;
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 = "scopeURL")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub scope_url: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(UnregisterParams {
scope_url: fields.scope_url,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Unregister;
#[derive(Debug, Clone, serde::Serialize)]
pub struct UnregisterResponse {}
impl<'de> serde::Deserialize<'de> for UnregisterResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UnregisterResponse;
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(UnregisterResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Unregister {
type Params = UnregisterParams;
type Response = UnregisterResponse;
const METHOD: &'static str = "ServiceWorker.unregister";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct UpdateRegistrationParams {
#[serde(rename = "scopeURL")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub scope_url: String,
}
impl<'de> serde::Deserialize<'de> for UpdateRegistrationParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UpdateRegistrationParams;
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 = "scopeURL")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub scope_url: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(UpdateRegistrationParams {
scope_url: fields.scope_url,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct UpdateRegistration;
#[derive(Debug, Clone, serde::Serialize)]
pub struct UpdateRegistrationResponse {}
impl<'de> serde::Deserialize<'de> for UpdateRegistrationResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = UpdateRegistrationResponse;
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(UpdateRegistrationResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for UpdateRegistration {
type Params = UpdateRegistrationParams;
type Response = UpdateRegistrationResponse;
const METHOD: &'static str = "ServiceWorker.updateRegistration";
}