1use super::runtime;
3use super::storage;
4#[allow(unused_imports)]
5use super::types::*;
6#[allow(unused_imports)]
7use serde::{Deserialize, Serialize};
8#[allow(unused_imports)]
9use serde_json::Value as Json;
10#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
11pub enum KeyType {
12 #[serde(rename = "number")]
13 Number,
14 #[serde(rename = "string")]
15 String,
16 #[serde(rename = "date")]
17 Date,
18 #[serde(rename = "array")]
19 Array,
20}
21#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
22pub enum KeyPathType {
23 #[serde(rename = "null")]
24 Null,
25 #[serde(rename = "string")]
26 String,
27 #[serde(rename = "array")]
28 Array,
29}
30#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
31pub struct DatabaseWithObjectStores {
32 #[serde(default)]
33 #[serde(rename = "name")]
34 pub name: String,
35 #[serde(default)]
36 #[serde(rename = "version")]
37 pub version: JsFloat,
38 #[serde(rename = "objectStores")]
39 pub object_stores: Vec<ObjectStore>,
40}
41#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
42pub struct ObjectStore {
43 #[serde(default)]
44 #[serde(rename = "name")]
45 pub name: String,
46 #[serde(rename = "keyPath")]
47 pub key_path: KeyPath,
48 #[serde(default)]
49 #[serde(rename = "autoIncrement")]
50 pub auto_increment: bool,
51 #[serde(rename = "indexes")]
52 pub indexes: Vec<ObjectStoreIndex>,
53}
54#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
55pub struct ObjectStoreIndex {
56 #[serde(default)]
57 #[serde(rename = "name")]
58 pub name: String,
59 #[serde(rename = "keyPath")]
60 pub key_path: KeyPath,
61 #[serde(default)]
62 #[serde(rename = "unique")]
63 pub unique: bool,
64 #[serde(default)]
65 #[serde(rename = "multiEntry")]
66 pub multi_entry: bool,
67}
68#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
69pub struct Key {
70 #[serde(rename = "type")]
71 pub r#type: KeyType,
72 #[serde(skip_serializing_if = "Option::is_none")]
73 #[serde(default)]
74 #[serde(rename = "number")]
75 pub number: Option<JsFloat>,
76 #[serde(skip_serializing_if = "Option::is_none")]
77 #[serde(default)]
78 #[serde(rename = "string")]
79 pub string: Option<String>,
80 #[serde(skip_serializing_if = "Option::is_none")]
81 #[serde(default)]
82 #[serde(rename = "date")]
83 pub date: Option<JsFloat>,
84 #[serde(skip_serializing_if = "Option::is_none")]
85 #[serde(rename = "array")]
86 pub array: Option<Vec<Key>>,
87}
88#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
89pub struct KeyRange {
90 #[serde(skip_serializing_if = "Option::is_none")]
91 #[serde(rename = "lower")]
92 pub lower: Option<Key>,
93 #[serde(skip_serializing_if = "Option::is_none")]
94 #[serde(rename = "upper")]
95 pub upper: Option<Key>,
96 #[serde(default)]
97 #[serde(rename = "lowerOpen")]
98 pub lower_open: bool,
99 #[serde(default)]
100 #[serde(rename = "upperOpen")]
101 pub upper_open: bool,
102}
103#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
104pub struct DataEntry {
105 #[serde(rename = "key")]
106 pub key: runtime::RemoteObject,
107 #[serde(rename = "primaryKey")]
108 pub primary_key: runtime::RemoteObject,
109 #[serde(rename = "value")]
110 pub value: runtime::RemoteObject,
111}
112#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
113pub struct KeyPath {
114 #[serde(rename = "type")]
115 pub r#type: KeyPathType,
116 #[serde(skip_serializing_if = "Option::is_none")]
117 #[serde(default)]
118 #[serde(rename = "string")]
119 pub string: Option<String>,
120 #[serde(skip_serializing_if = "Option::is_none")]
121 #[serde(default)]
122 #[serde(rename = "array")]
123 pub array: Option<Vec<String>>,
124}
125#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
126pub struct ClearObjectStore {
127 #[serde(skip_serializing_if = "Option::is_none")]
128 #[serde(default)]
129 #[serde(rename = "securityOrigin")]
130 pub security_origin: Option<String>,
131 #[serde(skip_serializing_if = "Option::is_none")]
132 #[serde(default)]
133 #[serde(rename = "storageKey")]
134 pub storage_key: Option<String>,
135 #[serde(skip_serializing_if = "Option::is_none")]
136 #[serde(rename = "storageBucket")]
137 pub storage_bucket: Option<storage::StorageBucket>,
138 #[serde(default)]
139 #[serde(rename = "databaseName")]
140 pub database_name: String,
141 #[serde(default)]
142 #[serde(rename = "objectStoreName")]
143 pub object_store_name: String,
144}
145#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
146pub struct DeleteDatabase {
147 #[serde(skip_serializing_if = "Option::is_none")]
148 #[serde(default)]
149 #[serde(rename = "securityOrigin")]
150 pub security_origin: Option<String>,
151 #[serde(skip_serializing_if = "Option::is_none")]
152 #[serde(default)]
153 #[serde(rename = "storageKey")]
154 pub storage_key: Option<String>,
155 #[serde(skip_serializing_if = "Option::is_none")]
156 #[serde(rename = "storageBucket")]
157 pub storage_bucket: Option<storage::StorageBucket>,
158 #[serde(default)]
159 #[serde(rename = "databaseName")]
160 pub database_name: String,
161}
162#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
163pub struct DeleteObjectStoreEntries {
164 #[serde(skip_serializing_if = "Option::is_none")]
165 #[serde(default)]
166 #[serde(rename = "securityOrigin")]
167 pub security_origin: Option<String>,
168 #[serde(skip_serializing_if = "Option::is_none")]
169 #[serde(default)]
170 #[serde(rename = "storageKey")]
171 pub storage_key: Option<String>,
172 #[serde(skip_serializing_if = "Option::is_none")]
173 #[serde(rename = "storageBucket")]
174 pub storage_bucket: Option<storage::StorageBucket>,
175 #[serde(default)]
176 #[serde(rename = "databaseName")]
177 pub database_name: String,
178 #[serde(default)]
179 #[serde(rename = "objectStoreName")]
180 pub object_store_name: String,
181 #[serde(rename = "keyRange")]
182 pub key_range: KeyRange,
183}
184#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
185#[serde(rename_all = "camelCase")]
186pub struct Disable(pub Option<serde_json::Value>);
187#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
188#[serde(rename_all = "camelCase")]
189pub struct Enable(pub Option<serde_json::Value>);
190#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
191pub struct RequestData {
192 #[serde(skip_serializing_if = "Option::is_none")]
193 #[serde(default)]
194 #[serde(rename = "securityOrigin")]
195 pub security_origin: Option<String>,
196 #[serde(skip_serializing_if = "Option::is_none")]
197 #[serde(default)]
198 #[serde(rename = "storageKey")]
199 pub storage_key: Option<String>,
200 #[serde(skip_serializing_if = "Option::is_none")]
201 #[serde(rename = "storageBucket")]
202 pub storage_bucket: Option<storage::StorageBucket>,
203 #[serde(default)]
204 #[serde(rename = "databaseName")]
205 pub database_name: String,
206 #[serde(default)]
207 #[serde(rename = "objectStoreName")]
208 pub object_store_name: String,
209 #[serde(default)]
210 #[serde(rename = "indexName")]
211 pub index_name: String,
212 #[serde(default)]
213 #[serde(rename = "skipCount")]
214 pub skip_count: JsUInt,
215 #[serde(default)]
216 #[serde(rename = "pageSize")]
217 pub page_size: JsUInt,
218 #[serde(skip_serializing_if = "Option::is_none")]
219 #[serde(rename = "keyRange")]
220 pub key_range: Option<KeyRange>,
221}
222#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
223pub struct GetMetadata {
224 #[serde(skip_serializing_if = "Option::is_none")]
225 #[serde(default)]
226 #[serde(rename = "securityOrigin")]
227 pub security_origin: Option<String>,
228 #[serde(skip_serializing_if = "Option::is_none")]
229 #[serde(default)]
230 #[serde(rename = "storageKey")]
231 pub storage_key: Option<String>,
232 #[serde(skip_serializing_if = "Option::is_none")]
233 #[serde(rename = "storageBucket")]
234 pub storage_bucket: Option<storage::StorageBucket>,
235 #[serde(default)]
236 #[serde(rename = "databaseName")]
237 pub database_name: String,
238 #[serde(default)]
239 #[serde(rename = "objectStoreName")]
240 pub object_store_name: String,
241}
242#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
243pub struct RequestDatabase {
244 #[serde(skip_serializing_if = "Option::is_none")]
245 #[serde(default)]
246 #[serde(rename = "securityOrigin")]
247 pub security_origin: Option<String>,
248 #[serde(skip_serializing_if = "Option::is_none")]
249 #[serde(default)]
250 #[serde(rename = "storageKey")]
251 pub storage_key: Option<String>,
252 #[serde(skip_serializing_if = "Option::is_none")]
253 #[serde(rename = "storageBucket")]
254 pub storage_bucket: Option<storage::StorageBucket>,
255 #[serde(default)]
256 #[serde(rename = "databaseName")]
257 pub database_name: String,
258}
259#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
260pub struct RequestDatabaseNames {
261 #[serde(skip_serializing_if = "Option::is_none")]
262 #[serde(default)]
263 #[serde(rename = "securityOrigin")]
264 pub security_origin: Option<String>,
265 #[serde(skip_serializing_if = "Option::is_none")]
266 #[serde(default)]
267 #[serde(rename = "storageKey")]
268 pub storage_key: Option<String>,
269 #[serde(skip_serializing_if = "Option::is_none")]
270 #[serde(rename = "storageBucket")]
271 pub storage_bucket: Option<storage::StorageBucket>,
272}
273#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
274#[serde(rename_all = "camelCase")]
275pub struct ClearObjectStoreReturnObject {}
276#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
277#[serde(rename_all = "camelCase")]
278pub struct DeleteDatabaseReturnObject {}
279#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
280#[serde(rename_all = "camelCase")]
281pub struct DeleteObjectStoreEntriesReturnObject {}
282#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
283#[serde(rename_all = "camelCase")]
284pub struct DisableReturnObject {}
285#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
286#[serde(rename_all = "camelCase")]
287pub struct EnableReturnObject {}
288#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
289pub struct RequestDataReturnObject {
290 #[serde(rename = "objectStoreDataEntries")]
291 pub object_store_data_entries: Vec<DataEntry>,
292 #[serde(default)]
293 #[serde(rename = "hasMore")]
294 pub has_more: bool,
295}
296#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
297pub struct GetMetadataReturnObject {
298 #[serde(default)]
299 #[serde(rename = "entriesCount")]
300 pub entries_count: JsFloat,
301 #[serde(default)]
302 #[serde(rename = "keyGeneratorValue")]
303 pub key_generator_value: JsFloat,
304}
305#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
306pub struct RequestDatabaseReturnObject {
307 #[serde(rename = "databaseWithObjectStores")]
308 pub database_with_object_stores: DatabaseWithObjectStores,
309}
310#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
311pub struct RequestDatabaseNamesReturnObject {
312 #[serde(rename = "databaseNames")]
313 pub database_names: Vec<String>,
314}
315impl Method for ClearObjectStore {
316 const NAME: &'static str = "IndexedDB.clearObjectStore";
317 type ReturnObject = ClearObjectStoreReturnObject;
318}
319impl Method for DeleteDatabase {
320 const NAME: &'static str = "IndexedDB.deleteDatabase";
321 type ReturnObject = DeleteDatabaseReturnObject;
322}
323impl Method for DeleteObjectStoreEntries {
324 const NAME: &'static str = "IndexedDB.deleteObjectStoreEntries";
325 type ReturnObject = DeleteObjectStoreEntriesReturnObject;
326}
327impl Method for Disable {
328 const NAME: &'static str = "IndexedDB.disable";
329 type ReturnObject = DisableReturnObject;
330}
331impl Method for Enable {
332 const NAME: &'static str = "IndexedDB.enable";
333 type ReturnObject = EnableReturnObject;
334}
335impl Method for RequestData {
336 const NAME: &'static str = "IndexedDB.requestData";
337 type ReturnObject = RequestDataReturnObject;
338}
339impl Method for GetMetadata {
340 const NAME: &'static str = "IndexedDB.getMetadata";
341 type ReturnObject = GetMetadataReturnObject;
342}
343impl Method for RequestDatabase {
344 const NAME: &'static str = "IndexedDB.requestDatabase";
345 type ReturnObject = RequestDatabaseReturnObject;
346}
347impl Method for RequestDatabaseNames {
348 const NAME: &'static str = "IndexedDB.requestDatabaseNames";
349 type ReturnObject = RequestDatabaseNamesReturnObject;
350}
351pub mod events {
352 #[allow(unused_imports)]
353 use super::super::types::*;
354 #[allow(unused_imports)]
355 use serde::{Deserialize, Serialize};
356}