1use super::storage;
3#[allow(unused_imports)]
4use super::types::*;
5#[allow(unused_imports)]
6use serde::{Deserialize, Serialize};
7#[allow(unused_imports)]
8use serde_json::Value as Json;
9pub type CacheId = String;
10#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
11pub enum CachedResponseType {
12 #[serde(rename = "basic")]
13 Basic,
14 #[serde(rename = "cors")]
15 Cors,
16 #[serde(rename = "default")]
17 Default,
18 #[serde(rename = "error")]
19 Error,
20 #[serde(rename = "opaqueResponse")]
21 OpaqueResponse,
22 #[serde(rename = "opaqueRedirect")]
23 OpaqueRedirect,
24}
25#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
26pub struct DataEntry {
27 #[serde(default)]
28 #[serde(rename = "requestURL")]
29 pub request_url: String,
30 #[serde(default)]
31 #[serde(rename = "requestMethod")]
32 pub request_method: String,
33 #[serde(rename = "requestHeaders")]
34 pub request_headers: Vec<Header>,
35 #[serde(default)]
36 #[serde(rename = "responseTime")]
37 pub response_time: JsFloat,
38 #[serde(default)]
39 #[serde(rename = "responseStatus")]
40 pub response_status: JsUInt,
41 #[serde(default)]
42 #[serde(rename = "responseStatusText")]
43 pub response_status_text: String,
44 #[serde(rename = "responseType")]
45 pub response_type: CachedResponseType,
46 #[serde(rename = "responseHeaders")]
47 pub response_headers: Vec<Header>,
48}
49#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
50pub struct Cache {
51 #[serde(rename = "cacheId")]
52 pub cache_id: CacheId,
53 #[serde(default)]
54 #[serde(rename = "securityOrigin")]
55 pub security_origin: String,
56 #[serde(default)]
57 #[serde(rename = "storageKey")]
58 pub storage_key: String,
59 #[serde(skip_serializing_if = "Option::is_none")]
60 #[serde(rename = "storageBucket")]
61 pub storage_bucket: Option<storage::StorageBucket>,
62 #[serde(default)]
63 #[serde(rename = "cacheName")]
64 pub cache_name: String,
65}
66#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
67pub struct Header {
68 #[serde(default)]
69 #[serde(rename = "name")]
70 pub name: String,
71 #[serde(default)]
72 #[serde(rename = "value")]
73 pub value: String,
74}
75#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
76pub struct CachedResponse {
77 #[serde(rename = "body")]
78 pub body: Vec<u8>,
79}
80#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
81pub struct DeleteCache {
82 #[serde(rename = "cacheId")]
83 pub cache_id: CacheId,
84}
85#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
86pub struct DeleteEntry {
87 #[serde(rename = "cacheId")]
88 pub cache_id: CacheId,
89 #[serde(default)]
90 #[serde(rename = "request")]
91 pub request: String,
92}
93#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
94pub struct RequestCacheNames {
95 #[serde(skip_serializing_if = "Option::is_none")]
96 #[serde(default)]
97 #[serde(rename = "securityOrigin")]
98 pub security_origin: Option<String>,
99 #[serde(skip_serializing_if = "Option::is_none")]
100 #[serde(default)]
101 #[serde(rename = "storageKey")]
102 pub storage_key: Option<String>,
103 #[serde(skip_serializing_if = "Option::is_none")]
104 #[serde(rename = "storageBucket")]
105 pub storage_bucket: Option<storage::StorageBucket>,
106}
107#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
108pub struct RequestCachedResponse {
109 #[serde(rename = "cacheId")]
110 pub cache_id: CacheId,
111 #[serde(default)]
112 #[serde(rename = "requestURL")]
113 pub request_url: String,
114 #[serde(rename = "requestHeaders")]
115 pub request_headers: Vec<Header>,
116}
117#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
118pub struct RequestEntries {
119 #[serde(rename = "cacheId")]
120 pub cache_id: CacheId,
121 #[serde(skip_serializing_if = "Option::is_none")]
122 #[serde(default)]
123 #[serde(rename = "skipCount")]
124 pub skip_count: Option<JsUInt>,
125 #[serde(skip_serializing_if = "Option::is_none")]
126 #[serde(default)]
127 #[serde(rename = "pageSize")]
128 pub page_size: Option<JsUInt>,
129 #[serde(skip_serializing_if = "Option::is_none")]
130 #[serde(default)]
131 #[serde(rename = "pathFilter")]
132 pub path_filter: Option<String>,
133}
134#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
135#[serde(rename_all = "camelCase")]
136pub struct DeleteCacheReturnObject {}
137#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
138#[serde(rename_all = "camelCase")]
139pub struct DeleteEntryReturnObject {}
140#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
141pub struct RequestCacheNamesReturnObject {
142 #[serde(rename = "caches")]
143 pub caches: Vec<Cache>,
144}
145#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
146pub struct RequestCachedResponseReturnObject {
147 #[serde(rename = "response")]
148 pub response: CachedResponse,
149}
150#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
151pub struct RequestEntriesReturnObject {
152 #[serde(rename = "cacheDataEntries")]
153 pub cache_data_entries: Vec<DataEntry>,
154 #[serde(default)]
155 #[serde(rename = "returnCount")]
156 pub return_count: JsFloat,
157}
158impl Method for DeleteCache {
159 const NAME: &'static str = "CacheStorage.deleteCache";
160 type ReturnObject = DeleteCacheReturnObject;
161}
162impl Method for DeleteEntry {
163 const NAME: &'static str = "CacheStorage.deleteEntry";
164 type ReturnObject = DeleteEntryReturnObject;
165}
166impl Method for RequestCacheNames {
167 const NAME: &'static str = "CacheStorage.requestCacheNames";
168 type ReturnObject = RequestCacheNamesReturnObject;
169}
170impl Method for RequestCachedResponse {
171 const NAME: &'static str = "CacheStorage.requestCachedResponse";
172 type ReturnObject = RequestCachedResponseReturnObject;
173}
174impl Method for RequestEntries {
175 const NAME: &'static str = "CacheStorage.requestEntries";
176 type ReturnObject = RequestEntriesReturnObject;
177}
178pub mod events {
179 #[allow(unused_imports)]
180 use super::super::types::*;
181 #[allow(unused_imports)]
182 use serde::{Deserialize, Serialize};
183}