cdp_protocol/
indexed_db.rs

1// Auto-generated from Chrome at version 140.0.7339.186 domain: IndexedDB
2use 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}