clientapi_pbs/apis/
admin_datastore_api.rs

1/*
2 * Proxmox Backup Server API
3 *
4 * Generated from apidoc.js. NOT an official Proxmox specification. See https://pbs.proxmox.com/docs/api-viewer/ for the upstream documentation.
5 *
6 * The version of the OpenAPI document: 9.x
7 * 
8 * Generated by: https://openapi-generator.tech
9 */
10
11
12use reqwest;
13use serde::{Deserialize, Serialize, de::Error as _};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration, ContentType};
16
17
18/// struct for typed errors of method [`admin_datastore_create_change_owner`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum AdminDatastoreCreateChangeOwnerError {
22    Status400(models::PbsError),
23    Status401(models::PbsError),
24    Status403(models::PbsError),
25    Status404(models::PbsError),
26    Status500(models::PbsError),
27    Status501(models::PbsError),
28    Status503(models::PbsError),
29    UnknownValue(serde_json::Value),
30}
31
32/// struct for typed errors of method [`admin_datastore_create_gc`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum AdminDatastoreCreateGcError {
36    Status400(models::PbsError),
37    Status401(models::PbsError),
38    Status403(models::PbsError),
39    Status404(models::PbsError),
40    Status500(models::PbsError),
41    Status501(models::PbsError),
42    Status503(models::PbsError),
43    UnknownValue(serde_json::Value),
44}
45
46/// struct for typed errors of method [`admin_datastore_create_mount`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum AdminDatastoreCreateMountError {
50    Status400(models::PbsError),
51    Status401(models::PbsError),
52    Status403(models::PbsError),
53    Status404(models::PbsError),
54    Status500(models::PbsError),
55    Status501(models::PbsError),
56    Status503(models::PbsError),
57    UnknownValue(serde_json::Value),
58}
59
60/// struct for typed errors of method [`admin_datastore_create_move_group`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum AdminDatastoreCreateMoveGroupError {
64    Status400(models::PbsError),
65    Status401(models::PbsError),
66    Status403(models::PbsError),
67    Status404(models::PbsError),
68    Status500(models::PbsError),
69    Status501(models::PbsError),
70    Status503(models::PbsError),
71    UnknownValue(serde_json::Value),
72}
73
74/// struct for typed errors of method [`admin_datastore_create_move_namespace`]
75#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum AdminDatastoreCreateMoveNamespaceError {
78    Status400(models::PbsError),
79    Status401(models::PbsError),
80    Status403(models::PbsError),
81    Status404(models::PbsError),
82    Status500(models::PbsError),
83    Status501(models::PbsError),
84    Status503(models::PbsError),
85    UnknownValue(serde_json::Value),
86}
87
88/// struct for typed errors of method [`admin_datastore_create_namespace`]
89#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum AdminDatastoreCreateNamespaceError {
92    Status400(models::PbsError),
93    Status401(models::PbsError),
94    Status403(models::PbsError),
95    Status404(models::PbsError),
96    Status500(models::PbsError),
97    Status501(models::PbsError),
98    Status503(models::PbsError),
99    UnknownValue(serde_json::Value),
100}
101
102/// struct for typed errors of method [`admin_datastore_create_prune`]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum AdminDatastoreCreatePruneError {
106    Status400(models::PbsError),
107    Status401(models::PbsError),
108    Status403(models::PbsError),
109    Status404(models::PbsError),
110    Status500(models::PbsError),
111    Status501(models::PbsError),
112    Status503(models::PbsError),
113    UnknownValue(serde_json::Value),
114}
115
116/// struct for typed errors of method [`admin_datastore_create_prune_datastore`]
117#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum AdminDatastoreCreatePruneDatastoreError {
120    Status400(models::PbsError),
121    Status401(models::PbsError),
122    Status403(models::PbsError),
123    Status404(models::PbsError),
124    Status500(models::PbsError),
125    Status501(models::PbsError),
126    Status503(models::PbsError),
127    UnknownValue(serde_json::Value),
128}
129
130/// struct for typed errors of method [`admin_datastore_create_unmount`]
131#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum AdminDatastoreCreateUnmountError {
134    Status400(models::PbsError),
135    Status401(models::PbsError),
136    Status403(models::PbsError),
137    Status404(models::PbsError),
138    Status500(models::PbsError),
139    Status501(models::PbsError),
140    Status503(models::PbsError),
141    UnknownValue(serde_json::Value),
142}
143
144/// struct for typed errors of method [`admin_datastore_create_upload_backup_log`]
145#[derive(Debug, Clone, Serialize, Deserialize)]
146#[serde(untagged)]
147pub enum AdminDatastoreCreateUploadBackupLogError {
148    Status400(models::PbsError),
149    Status401(models::PbsError),
150    Status403(models::PbsError),
151    Status404(models::PbsError),
152    Status500(models::PbsError),
153    Status501(models::PbsError),
154    Status503(models::PbsError),
155    UnknownValue(serde_json::Value),
156}
157
158/// struct for typed errors of method [`admin_datastore_create_verify`]
159#[derive(Debug, Clone, Serialize, Deserialize)]
160#[serde(untagged)]
161pub enum AdminDatastoreCreateVerifyError {
162    Status400(models::PbsError),
163    Status401(models::PbsError),
164    Status403(models::PbsError),
165    Status404(models::PbsError),
166    Status500(models::PbsError),
167    Status501(models::PbsError),
168    Status503(models::PbsError),
169    UnknownValue(serde_json::Value),
170}
171
172/// struct for typed errors of method [`admin_datastore_delete_groups`]
173#[derive(Debug, Clone, Serialize, Deserialize)]
174#[serde(untagged)]
175pub enum AdminDatastoreDeleteGroupsError {
176    Status400(models::PbsError),
177    Status401(models::PbsError),
178    Status403(models::PbsError),
179    Status404(models::PbsError),
180    Status500(models::PbsError),
181    Status501(models::PbsError),
182    Status503(models::PbsError),
183    UnknownValue(serde_json::Value),
184}
185
186/// struct for typed errors of method [`admin_datastore_delete_namespace`]
187#[derive(Debug, Clone, Serialize, Deserialize)]
188#[serde(untagged)]
189pub enum AdminDatastoreDeleteNamespaceError {
190    Status400(models::PbsError),
191    Status401(models::PbsError),
192    Status403(models::PbsError),
193    Status404(models::PbsError),
194    Status500(models::PbsError),
195    Status501(models::PbsError),
196    Status503(models::PbsError),
197    UnknownValue(serde_json::Value),
198}
199
200/// struct for typed errors of method [`admin_datastore_delete_snapshots`]
201#[derive(Debug, Clone, Serialize, Deserialize)]
202#[serde(untagged)]
203pub enum AdminDatastoreDeleteSnapshotsError {
204    Status400(models::PbsError),
205    Status401(models::PbsError),
206    Status403(models::PbsError),
207    Status404(models::PbsError),
208    Status500(models::PbsError),
209    Status501(models::PbsError),
210    Status503(models::PbsError),
211    UnknownValue(serde_json::Value),
212}
213
214/// struct for typed errors of method [`admin_datastore_get_active_operations`]
215#[derive(Debug, Clone, Serialize, Deserialize)]
216#[serde(untagged)]
217pub enum AdminDatastoreGetActiveOperationsError {
218    Status400(models::PbsError),
219    Status401(models::PbsError),
220    Status403(models::PbsError),
221    Status404(models::PbsError),
222    Status500(models::PbsError),
223    Status501(models::PbsError),
224    Status503(models::PbsError),
225    UnknownValue(serde_json::Value),
226}
227
228/// struct for typed errors of method [`admin_datastore_get_admin_datastore_by_store`]
229#[derive(Debug, Clone, Serialize, Deserialize)]
230#[serde(untagged)]
231pub enum AdminDatastoreGetAdminDatastoreByStoreError {
232    Status400(models::PbsError),
233    Status401(models::PbsError),
234    Status403(models::PbsError),
235    Status404(models::PbsError),
236    Status500(models::PbsError),
237    Status501(models::PbsError),
238    Status503(models::PbsError),
239    UnknownValue(serde_json::Value),
240}
241
242/// struct for typed errors of method [`admin_datastore_get_catalog`]
243#[derive(Debug, Clone, Serialize, Deserialize)]
244#[serde(untagged)]
245pub enum AdminDatastoreGetCatalogError {
246    Status400(models::PbsError),
247    Status401(models::PbsError),
248    Status403(models::PbsError),
249    Status404(models::PbsError),
250    Status500(models::PbsError),
251    Status501(models::PbsError),
252    Status503(models::PbsError),
253    UnknownValue(serde_json::Value),
254}
255
256/// struct for typed errors of method [`admin_datastore_get_datastore`]
257#[derive(Debug, Clone, Serialize, Deserialize)]
258#[serde(untagged)]
259pub enum AdminDatastoreGetDatastoreError {
260    Status400(models::PbsError),
261    Status401(models::PbsError),
262    Status403(models::PbsError),
263    Status404(models::PbsError),
264    Status500(models::PbsError),
265    Status501(models::PbsError),
266    Status503(models::PbsError),
267    UnknownValue(serde_json::Value),
268}
269
270/// struct for typed errors of method [`admin_datastore_get_download`]
271#[derive(Debug, Clone, Serialize, Deserialize)]
272#[serde(untagged)]
273pub enum AdminDatastoreGetDownloadError {
274    Status400(models::PbsError),
275    Status401(models::PbsError),
276    Status403(models::PbsError),
277    Status404(models::PbsError),
278    Status500(models::PbsError),
279    Status501(models::PbsError),
280    Status503(models::PbsError),
281    UnknownValue(serde_json::Value),
282}
283
284/// struct for typed errors of method [`admin_datastore_get_download_decoded`]
285#[derive(Debug, Clone, Serialize, Deserialize)]
286#[serde(untagged)]
287pub enum AdminDatastoreGetDownloadDecodedError {
288    Status400(models::PbsError),
289    Status401(models::PbsError),
290    Status403(models::PbsError),
291    Status404(models::PbsError),
292    Status500(models::PbsError),
293    Status501(models::PbsError),
294    Status503(models::PbsError),
295    UnknownValue(serde_json::Value),
296}
297
298/// struct for typed errors of method [`admin_datastore_get_files`]
299#[derive(Debug, Clone, Serialize, Deserialize)]
300#[serde(untagged)]
301pub enum AdminDatastoreGetFilesError {
302    Status400(models::PbsError),
303    Status401(models::PbsError),
304    Status403(models::PbsError),
305    Status404(models::PbsError),
306    Status500(models::PbsError),
307    Status501(models::PbsError),
308    Status503(models::PbsError),
309    UnknownValue(serde_json::Value),
310}
311
312/// struct for typed errors of method [`admin_datastore_get_gc`]
313#[derive(Debug, Clone, Serialize, Deserialize)]
314#[serde(untagged)]
315pub enum AdminDatastoreGetGcError {
316    Status400(models::PbsError),
317    Status401(models::PbsError),
318    Status403(models::PbsError),
319    Status404(models::PbsError),
320    Status500(models::PbsError),
321    Status501(models::PbsError),
322    Status503(models::PbsError),
323    UnknownValue(serde_json::Value),
324}
325
326/// struct for typed errors of method [`admin_datastore_get_group_notes`]
327#[derive(Debug, Clone, Serialize, Deserialize)]
328#[serde(untagged)]
329pub enum AdminDatastoreGetGroupNotesError {
330    Status400(models::PbsError),
331    Status401(models::PbsError),
332    Status403(models::PbsError),
333    Status404(models::PbsError),
334    Status500(models::PbsError),
335    Status501(models::PbsError),
336    Status503(models::PbsError),
337    UnknownValue(serde_json::Value),
338}
339
340/// struct for typed errors of method [`admin_datastore_get_groups`]
341#[derive(Debug, Clone, Serialize, Deserialize)]
342#[serde(untagged)]
343pub enum AdminDatastoreGetGroupsError {
344    Status400(models::PbsError),
345    Status401(models::PbsError),
346    Status403(models::PbsError),
347    Status404(models::PbsError),
348    Status500(models::PbsError),
349    Status501(models::PbsError),
350    Status503(models::PbsError),
351    UnknownValue(serde_json::Value),
352}
353
354/// struct for typed errors of method [`admin_datastore_get_namespace`]
355#[derive(Debug, Clone, Serialize, Deserialize)]
356#[serde(untagged)]
357pub enum AdminDatastoreGetNamespaceError {
358    Status400(models::PbsError),
359    Status401(models::PbsError),
360    Status403(models::PbsError),
361    Status404(models::PbsError),
362    Status500(models::PbsError),
363    Status501(models::PbsError),
364    Status503(models::PbsError),
365    UnknownValue(serde_json::Value),
366}
367
368/// struct for typed errors of method [`admin_datastore_get_notes`]
369#[derive(Debug, Clone, Serialize, Deserialize)]
370#[serde(untagged)]
371pub enum AdminDatastoreGetNotesError {
372    Status400(models::PbsError),
373    Status401(models::PbsError),
374    Status403(models::PbsError),
375    Status404(models::PbsError),
376    Status500(models::PbsError),
377    Status501(models::PbsError),
378    Status503(models::PbsError),
379    UnknownValue(serde_json::Value),
380}
381
382/// struct for typed errors of method [`admin_datastore_get_protected`]
383#[derive(Debug, Clone, Serialize, Deserialize)]
384#[serde(untagged)]
385pub enum AdminDatastoreGetProtectedError {
386    Status400(models::PbsError),
387    Status401(models::PbsError),
388    Status403(models::PbsError),
389    Status404(models::PbsError),
390    Status500(models::PbsError),
391    Status501(models::PbsError),
392    Status503(models::PbsError),
393    UnknownValue(serde_json::Value),
394}
395
396/// struct for typed errors of method [`admin_datastore_get_pxar_file_download`]
397#[derive(Debug, Clone, Serialize, Deserialize)]
398#[serde(untagged)]
399pub enum AdminDatastoreGetPxarFileDownloadError {
400    Status400(models::PbsError),
401    Status401(models::PbsError),
402    Status403(models::PbsError),
403    Status404(models::PbsError),
404    Status500(models::PbsError),
405    Status501(models::PbsError),
406    Status503(models::PbsError),
407    UnknownValue(serde_json::Value),
408}
409
410/// struct for typed errors of method [`admin_datastore_get_rrd`]
411#[derive(Debug, Clone, Serialize, Deserialize)]
412#[serde(untagged)]
413pub enum AdminDatastoreGetRrdError {
414    Status400(models::PbsError),
415    Status401(models::PbsError),
416    Status403(models::PbsError),
417    Status404(models::PbsError),
418    Status500(models::PbsError),
419    Status501(models::PbsError),
420    Status503(models::PbsError),
421    UnknownValue(serde_json::Value),
422}
423
424/// struct for typed errors of method [`admin_datastore_get_snapshots`]
425#[derive(Debug, Clone, Serialize, Deserialize)]
426#[serde(untagged)]
427pub enum AdminDatastoreGetSnapshotsError {
428    Status400(models::PbsError),
429    Status401(models::PbsError),
430    Status403(models::PbsError),
431    Status404(models::PbsError),
432    Status500(models::PbsError),
433    Status501(models::PbsError),
434    Status503(models::PbsError),
435    UnknownValue(serde_json::Value),
436}
437
438/// struct for typed errors of method [`admin_datastore_get_status`]
439#[derive(Debug, Clone, Serialize, Deserialize)]
440#[serde(untagged)]
441pub enum AdminDatastoreGetStatusError {
442    Status400(models::PbsError),
443    Status401(models::PbsError),
444    Status403(models::PbsError),
445    Status404(models::PbsError),
446    Status500(models::PbsError),
447    Status501(models::PbsError),
448    Status503(models::PbsError),
449    UnknownValue(serde_json::Value),
450}
451
452/// struct for typed errors of method [`admin_datastore_update_group_notes`]
453#[derive(Debug, Clone, Serialize, Deserialize)]
454#[serde(untagged)]
455pub enum AdminDatastoreUpdateGroupNotesError {
456    Status400(models::PbsError),
457    Status401(models::PbsError),
458    Status403(models::PbsError),
459    Status404(models::PbsError),
460    Status500(models::PbsError),
461    Status501(models::PbsError),
462    Status503(models::PbsError),
463    UnknownValue(serde_json::Value),
464}
465
466/// struct for typed errors of method [`admin_datastore_update_notes`]
467#[derive(Debug, Clone, Serialize, Deserialize)]
468#[serde(untagged)]
469pub enum AdminDatastoreUpdateNotesError {
470    Status400(models::PbsError),
471    Status401(models::PbsError),
472    Status403(models::PbsError),
473    Status404(models::PbsError),
474    Status500(models::PbsError),
475    Status501(models::PbsError),
476    Status503(models::PbsError),
477    UnknownValue(serde_json::Value),
478}
479
480/// struct for typed errors of method [`admin_datastore_update_protected`]
481#[derive(Debug, Clone, Serialize, Deserialize)]
482#[serde(untagged)]
483pub enum AdminDatastoreUpdateProtectedError {
484    Status400(models::PbsError),
485    Status401(models::PbsError),
486    Status403(models::PbsError),
487    Status404(models::PbsError),
488    Status500(models::PbsError),
489    Status501(models::PbsError),
490    Status503(models::PbsError),
491    UnknownValue(serde_json::Value),
492}
493
494/// struct for typed errors of method [`admin_datastore_update_s3_refresh`]
495#[derive(Debug, Clone, Serialize, Deserialize)]
496#[serde(untagged)]
497pub enum AdminDatastoreUpdateS3RefreshError {
498    Status400(models::PbsError),
499    Status401(models::PbsError),
500    Status403(models::PbsError),
501    Status404(models::PbsError),
502    Status500(models::PbsError),
503    Status501(models::PbsError),
504    Status503(models::PbsError),
505    UnknownValue(serde_json::Value),
506}
507
508
509/// Change owner of a backup group  Permissions: Datastore.Modify on whole datastore, or changing ownership between user and a user's token for owned backups with Datastore.Backup
510pub async fn admin_datastore_create_change_owner(configuration: &configuration::Configuration, store: &str, admin_datastore_create_change_owner_request: models::AdminDatastoreCreateChangeOwnerRequest) -> Result<models::AdminDatastoreCreateChangeOwnerResponse, Error<AdminDatastoreCreateChangeOwnerError>> {
511    // add a prefix to parameters to efficiently prevent name collisions
512    let p_path_store = store;
513    let p_body_admin_datastore_create_change_owner_request = admin_datastore_create_change_owner_request;
514
515    let uri_str = format!("{}/admin/datastore/{store}/change-owner", configuration.base_path, store=crate::apis::urlencode(p_path_store));
516    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
517
518    if let Some(ref user_agent) = configuration.user_agent {
519        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
520    }
521    if let Some(ref apikey) = configuration.api_key {
522        let key = apikey.key.clone();
523        let value = match apikey.prefix {
524            Some(ref prefix) => format!("{} {}", prefix, key),
525            None => key,
526        };
527        req_builder = req_builder.header("Authorization", value);
528    };
529    if let Some(ref apikey) = configuration.api_key {
530        let key = apikey.key.clone();
531        let value = match apikey.prefix {
532            Some(ref prefix) => format!("{} {}", prefix, key),
533            None => key,
534        };
535        req_builder = req_builder.header("CSRFPreventionToken", value);
536    };
537    req_builder = req_builder.json(&p_body_admin_datastore_create_change_owner_request);
538
539    let req = req_builder.build()?;
540    let resp = configuration.client.execute(req).await?;
541
542    let status = resp.status();
543    let content_type = resp
544        .headers()
545        .get("content-type")
546        .and_then(|v| v.to_str().ok())
547        .unwrap_or("application/octet-stream");
548    let content_type = super::ContentType::from(content_type);
549
550    if !status.is_client_error() && !status.is_server_error() {
551        let content = resp.text().await?;
552        match content_type {
553            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
554            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreCreateChangeOwnerResponse`"))),
555            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateChangeOwnerResponse`")))),
556        }
557    } else {
558        let content = resp.text().await?;
559        let entity: Option<AdminDatastoreCreateChangeOwnerError> = serde_json::from_str(&content).ok();
560        Err(Error::ResponseError(ResponseContent { status, content, entity }))
561    }
562}
563
564/// Start garbage collection.
565pub async fn admin_datastore_create_gc(configuration: &configuration::Configuration, store: &str) -> Result<models::AdminDatastoreCreateGcResponse, Error<AdminDatastoreCreateGcError>> {
566    // add a prefix to parameters to efficiently prevent name collisions
567    let p_path_store = store;
568
569    let uri_str = format!("{}/admin/datastore/{store}/gc", configuration.base_path, store=crate::apis::urlencode(p_path_store));
570    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
571
572    if let Some(ref user_agent) = configuration.user_agent {
573        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
574    }
575    if let Some(ref apikey) = configuration.api_key {
576        let key = apikey.key.clone();
577        let value = match apikey.prefix {
578            Some(ref prefix) => format!("{} {}", prefix, key),
579            None => key,
580        };
581        req_builder = req_builder.header("Authorization", value);
582    };
583    if let Some(ref apikey) = configuration.api_key {
584        let key = apikey.key.clone();
585        let value = match apikey.prefix {
586            Some(ref prefix) => format!("{} {}", prefix, key),
587            None => key,
588        };
589        req_builder = req_builder.header("CSRFPreventionToken", value);
590    };
591
592    let req = req_builder.build()?;
593    let resp = configuration.client.execute(req).await?;
594
595    let status = resp.status();
596    let content_type = resp
597        .headers()
598        .get("content-type")
599        .and_then(|v| v.to_str().ok())
600        .unwrap_or("application/octet-stream");
601    let content_type = super::ContentType::from(content_type);
602
603    if !status.is_client_error() && !status.is_server_error() {
604        let content = resp.text().await?;
605        match content_type {
606            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
607            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreCreateGcResponse`"))),
608            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateGcResponse`")))),
609        }
610    } else {
611        let content = resp.text().await?;
612        let entity: Option<AdminDatastoreCreateGcError> = serde_json::from_str(&content).ok();
613        Err(Error::ResponseError(ResponseContent { status, content, entity }))
614    }
615}
616
617/// Mount removable datastore.
618pub async fn admin_datastore_create_mount(configuration: &configuration::Configuration, store: &str) -> Result<models::AdminDatastoreCreateMountResponse, Error<AdminDatastoreCreateMountError>> {
619    // add a prefix to parameters to efficiently prevent name collisions
620    let p_path_store = store;
621
622    let uri_str = format!("{}/admin/datastore/{store}/mount", configuration.base_path, store=crate::apis::urlencode(p_path_store));
623    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
624
625    if let Some(ref user_agent) = configuration.user_agent {
626        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
627    }
628    if let Some(ref apikey) = configuration.api_key {
629        let key = apikey.key.clone();
630        let value = match apikey.prefix {
631            Some(ref prefix) => format!("{} {}", prefix, key),
632            None => key,
633        };
634        req_builder = req_builder.header("Authorization", value);
635    };
636    if let Some(ref apikey) = configuration.api_key {
637        let key = apikey.key.clone();
638        let value = match apikey.prefix {
639            Some(ref prefix) => format!("{} {}", prefix, key),
640            None => key,
641        };
642        req_builder = req_builder.header("CSRFPreventionToken", value);
643    };
644
645    let req = req_builder.build()?;
646    let resp = configuration.client.execute(req).await?;
647
648    let status = resp.status();
649    let content_type = resp
650        .headers()
651        .get("content-type")
652        .and_then(|v| v.to_str().ok())
653        .unwrap_or("application/octet-stream");
654    let content_type = super::ContentType::from(content_type);
655
656    if !status.is_client_error() && !status.is_server_error() {
657        let content = resp.text().await?;
658        match content_type {
659            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
660            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreCreateMountResponse`"))),
661            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateMountResponse`")))),
662        }
663    } else {
664        let content = resp.text().await?;
665        let entity: Option<AdminDatastoreCreateMountError> = serde_json::from_str(&content).ok();
666        Err(Error::ResponseError(ResponseContent { status, content, entity }))
667    }
668}
669
670/// Move a backup group to a different namespace within the same datastore.  Permissions: Requires DATASTORE_MODIFY or DATASTORE_PRUNE (+ group ownership) on the source namespace and DATASTORE_MODIFY or DATASTORE_BACKUP (+ group ownership) on the target namespace.
671pub async fn admin_datastore_create_move_group(configuration: &configuration::Configuration, store: &str, admin_datastore_create_move_group_request: models::AdminDatastoreCreateMoveGroupRequest) -> Result<models::AdminDatastoreCreateMoveGroupResponse, Error<AdminDatastoreCreateMoveGroupError>> {
672    // add a prefix to parameters to efficiently prevent name collisions
673    let p_path_store = store;
674    let p_body_admin_datastore_create_move_group_request = admin_datastore_create_move_group_request;
675
676    let uri_str = format!("{}/admin/datastore/{store}/move-group", configuration.base_path, store=crate::apis::urlencode(p_path_store));
677    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
678
679    if let Some(ref user_agent) = configuration.user_agent {
680        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
681    }
682    if let Some(ref apikey) = configuration.api_key {
683        let key = apikey.key.clone();
684        let value = match apikey.prefix {
685            Some(ref prefix) => format!("{} {}", prefix, key),
686            None => key,
687        };
688        req_builder = req_builder.header("Authorization", value);
689    };
690    if let Some(ref apikey) = configuration.api_key {
691        let key = apikey.key.clone();
692        let value = match apikey.prefix {
693            Some(ref prefix) => format!("{} {}", prefix, key),
694            None => key,
695        };
696        req_builder = req_builder.header("CSRFPreventionToken", value);
697    };
698    req_builder = req_builder.json(&p_body_admin_datastore_create_move_group_request);
699
700    let req = req_builder.build()?;
701    let resp = configuration.client.execute(req).await?;
702
703    let status = resp.status();
704    let content_type = resp
705        .headers()
706        .get("content-type")
707        .and_then(|v| v.to_str().ok())
708        .unwrap_or("application/octet-stream");
709    let content_type = super::ContentType::from(content_type);
710
711    if !status.is_client_error() && !status.is_server_error() {
712        let content = resp.text().await?;
713        match content_type {
714            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
715            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreCreateMoveGroupResponse`"))),
716            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateMoveGroupResponse`")))),
717        }
718    } else {
719        let content = resp.text().await?;
720        let entity: Option<AdminDatastoreCreateMoveGroupError> = serde_json::from_str(&content).ok();
721        Err(Error::ResponseError(ResponseContent { status, content, entity }))
722    }
723}
724
725/// Move a backup namespace (including all child namespaces and groups) to a new location.  Permissions: Requires DATASTORE_MODIFY on the parent of 'ns' and on the parent of 'target-ns'.
726pub async fn admin_datastore_create_move_namespace(configuration: &configuration::Configuration, store: &str, admin_datastore_create_move_namespace_request: models::AdminDatastoreCreateMoveNamespaceRequest) -> Result<models::AdminDatastoreCreateMoveNamespaceResponse, Error<AdminDatastoreCreateMoveNamespaceError>> {
727    // add a prefix to parameters to efficiently prevent name collisions
728    let p_path_store = store;
729    let p_body_admin_datastore_create_move_namespace_request = admin_datastore_create_move_namespace_request;
730
731    let uri_str = format!("{}/admin/datastore/{store}/move-namespace", configuration.base_path, store=crate::apis::urlencode(p_path_store));
732    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
733
734    if let Some(ref user_agent) = configuration.user_agent {
735        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
736    }
737    if let Some(ref apikey) = configuration.api_key {
738        let key = apikey.key.clone();
739        let value = match apikey.prefix {
740            Some(ref prefix) => format!("{} {}", prefix, key),
741            None => key,
742        };
743        req_builder = req_builder.header("Authorization", value);
744    };
745    if let Some(ref apikey) = configuration.api_key {
746        let key = apikey.key.clone();
747        let value = match apikey.prefix {
748            Some(ref prefix) => format!("{} {}", prefix, key),
749            None => key,
750        };
751        req_builder = req_builder.header("CSRFPreventionToken", value);
752    };
753    req_builder = req_builder.json(&p_body_admin_datastore_create_move_namespace_request);
754
755    let req = req_builder.build()?;
756    let resp = configuration.client.execute(req).await?;
757
758    let status = resp.status();
759    let content_type = resp
760        .headers()
761        .get("content-type")
762        .and_then(|v| v.to_str().ok())
763        .unwrap_or("application/octet-stream");
764    let content_type = super::ContentType::from(content_type);
765
766    if !status.is_client_error() && !status.is_server_error() {
767        let content = resp.text().await?;
768        match content_type {
769            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
770            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreCreateMoveNamespaceResponse`"))),
771            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateMoveNamespaceResponse`")))),
772        }
773    } else {
774        let content = resp.text().await?;
775        let entity: Option<AdminDatastoreCreateMoveNamespaceError> = serde_json::from_str(&content).ok();
776        Err(Error::ResponseError(ResponseContent { status, content, entity }))
777    }
778}
779
780/// Create a new datastore namespace.  Permissions: Requires on /datastore/{store}[/{parent}] DATASTORE_MODIFY
781pub async fn admin_datastore_create_namespace(configuration: &configuration::Configuration, store: &str, admin_datastore_create_namespace_request: models::AdminDatastoreCreateNamespaceRequest) -> Result<models::AdminDatastoreCreateNamespaceResponse, Error<AdminDatastoreCreateNamespaceError>> {
782    // add a prefix to parameters to efficiently prevent name collisions
783    let p_path_store = store;
784    let p_body_admin_datastore_create_namespace_request = admin_datastore_create_namespace_request;
785
786    let uri_str = format!("{}/admin/datastore/{store}/namespace", configuration.base_path, store=crate::apis::urlencode(p_path_store));
787    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
788
789    if let Some(ref user_agent) = configuration.user_agent {
790        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
791    }
792    if let Some(ref apikey) = configuration.api_key {
793        let key = apikey.key.clone();
794        let value = match apikey.prefix {
795            Some(ref prefix) => format!("{} {}", prefix, key),
796            None => key,
797        };
798        req_builder = req_builder.header("Authorization", value);
799    };
800    if let Some(ref apikey) = configuration.api_key {
801        let key = apikey.key.clone();
802        let value = match apikey.prefix {
803            Some(ref prefix) => format!("{} {}", prefix, key),
804            None => key,
805        };
806        req_builder = req_builder.header("CSRFPreventionToken", value);
807    };
808    req_builder = req_builder.json(&p_body_admin_datastore_create_namespace_request);
809
810    let req = req_builder.build()?;
811    let resp = configuration.client.execute(req).await?;
812
813    let status = resp.status();
814    let content_type = resp
815        .headers()
816        .get("content-type")
817        .and_then(|v| v.to_str().ok())
818        .unwrap_or("application/octet-stream");
819    let content_type = super::ContentType::from(content_type);
820
821    if !status.is_client_error() && !status.is_server_error() {
822        let content = resp.text().await?;
823        match content_type {
824            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
825            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreCreateNamespaceResponse`"))),
826            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateNamespaceResponse`")))),
827        }
828    } else {
829        let content = resp.text().await?;
830        let entity: Option<AdminDatastoreCreateNamespaceError> = serde_json::from_str(&content).ok();
831        Err(Error::ResponseError(ResponseContent { status, content, entity }))
832    }
833}
834
835/// Prune a group on the datastore  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_MODIFY for any or DATASTORE_PRUNE and being the owner of the group
836pub async fn admin_datastore_create_prune(configuration: &configuration::Configuration, store: &str, admin_datastore_create_prune_request: models::AdminDatastoreCreatePruneRequest) -> Result<models::AdminDatastoreCreatePruneResponse, Error<AdminDatastoreCreatePruneError>> {
837    // add a prefix to parameters to efficiently prevent name collisions
838    let p_path_store = store;
839    let p_body_admin_datastore_create_prune_request = admin_datastore_create_prune_request;
840
841    let uri_str = format!("{}/admin/datastore/{store}/prune", configuration.base_path, store=crate::apis::urlencode(p_path_store));
842    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
843
844    if let Some(ref user_agent) = configuration.user_agent {
845        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
846    }
847    if let Some(ref apikey) = configuration.api_key {
848        let key = apikey.key.clone();
849        let value = match apikey.prefix {
850            Some(ref prefix) => format!("{} {}", prefix, key),
851            None => key,
852        };
853        req_builder = req_builder.header("Authorization", value);
854    };
855    if let Some(ref apikey) = configuration.api_key {
856        let key = apikey.key.clone();
857        let value = match apikey.prefix {
858            Some(ref prefix) => format!("{} {}", prefix, key),
859            None => key,
860        };
861        req_builder = req_builder.header("CSRFPreventionToken", value);
862    };
863    req_builder = req_builder.json(&p_body_admin_datastore_create_prune_request);
864
865    let req = req_builder.build()?;
866    let resp = configuration.client.execute(req).await?;
867
868    let status = resp.status();
869    let content_type = resp
870        .headers()
871        .get("content-type")
872        .and_then(|v| v.to_str().ok())
873        .unwrap_or("application/octet-stream");
874    let content_type = super::ContentType::from(content_type);
875
876    if !status.is_client_error() && !status.is_server_error() {
877        let content = resp.text().await?;
878        match content_type {
879            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
880            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreCreatePruneResponse`"))),
881            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreatePruneResponse`")))),
882        }
883    } else {
884        let content = resp.text().await?;
885        let entity: Option<AdminDatastoreCreatePruneError> = serde_json::from_str(&content).ok();
886        Err(Error::ResponseError(ResponseContent { status, content, entity }))
887    }
888}
889
890/// Prune the datastore  Permissions: Requires Datastore.Modify or Datastore.Prune on the datastore/namespace.
891pub async fn admin_datastore_create_prune_datastore(configuration: &configuration::Configuration, store: &str, admin_datastore_create_prune_datastore_request: Option<models::AdminDatastoreCreatePruneDatastoreRequest>) -> Result<models::AdminDatastoreCreatePruneDatastoreResponse, Error<AdminDatastoreCreatePruneDatastoreError>> {
892    // add a prefix to parameters to efficiently prevent name collisions
893    let p_path_store = store;
894    let p_body_admin_datastore_create_prune_datastore_request = admin_datastore_create_prune_datastore_request;
895
896    let uri_str = format!("{}/admin/datastore/{store}/prune-datastore", configuration.base_path, store=crate::apis::urlencode(p_path_store));
897    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
898
899    if let Some(ref user_agent) = configuration.user_agent {
900        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
901    }
902    if let Some(ref apikey) = configuration.api_key {
903        let key = apikey.key.clone();
904        let value = match apikey.prefix {
905            Some(ref prefix) => format!("{} {}", prefix, key),
906            None => key,
907        };
908        req_builder = req_builder.header("Authorization", value);
909    };
910    if let Some(ref apikey) = configuration.api_key {
911        let key = apikey.key.clone();
912        let value = match apikey.prefix {
913            Some(ref prefix) => format!("{} {}", prefix, key),
914            None => key,
915        };
916        req_builder = req_builder.header("CSRFPreventionToken", value);
917    };
918    req_builder = req_builder.json(&p_body_admin_datastore_create_prune_datastore_request);
919
920    let req = req_builder.build()?;
921    let resp = configuration.client.execute(req).await?;
922
923    let status = resp.status();
924    let content_type = resp
925        .headers()
926        .get("content-type")
927        .and_then(|v| v.to_str().ok())
928        .unwrap_or("application/octet-stream");
929    let content_type = super::ContentType::from(content_type);
930
931    if !status.is_client_error() && !status.is_server_error() {
932        let content = resp.text().await?;
933        match content_type {
934            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
935            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreCreatePruneDatastoreResponse`"))),
936            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreatePruneDatastoreResponse`")))),
937        }
938    } else {
939        let content = resp.text().await?;
940        let entity: Option<AdminDatastoreCreatePruneDatastoreError> = serde_json::from_str(&content).ok();
941        Err(Error::ResponseError(ResponseContent { status, content, entity }))
942    }
943}
944
945/// Unmount a removable device that is associated with the datastore
946pub async fn admin_datastore_create_unmount(configuration: &configuration::Configuration, store: &str) -> Result<models::AdminDatastoreCreateUnmountResponse, Error<AdminDatastoreCreateUnmountError>> {
947    // add a prefix to parameters to efficiently prevent name collisions
948    let p_path_store = store;
949
950    let uri_str = format!("{}/admin/datastore/{store}/unmount", configuration.base_path, store=crate::apis::urlencode(p_path_store));
951    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
952
953    if let Some(ref user_agent) = configuration.user_agent {
954        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
955    }
956    if let Some(ref apikey) = configuration.api_key {
957        let key = apikey.key.clone();
958        let value = match apikey.prefix {
959            Some(ref prefix) => format!("{} {}", prefix, key),
960            None => key,
961        };
962        req_builder = req_builder.header("Authorization", value);
963    };
964    if let Some(ref apikey) = configuration.api_key {
965        let key = apikey.key.clone();
966        let value = match apikey.prefix {
967            Some(ref prefix) => format!("{} {}", prefix, key),
968            None => key,
969        };
970        req_builder = req_builder.header("CSRFPreventionToken", value);
971    };
972
973    let req = req_builder.build()?;
974    let resp = configuration.client.execute(req).await?;
975
976    let status = resp.status();
977    let content_type = resp
978        .headers()
979        .get("content-type")
980        .and_then(|v| v.to_str().ok())
981        .unwrap_or("application/octet-stream");
982    let content_type = super::ContentType::from(content_type);
983
984    if !status.is_client_error() && !status.is_server_error() {
985        let content = resp.text().await?;
986        match content_type {
987            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
988            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreCreateUnmountResponse`"))),
989            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateUnmountResponse`")))),
990        }
991    } else {
992        let content = resp.text().await?;
993        let entity: Option<AdminDatastoreCreateUnmountError> = serde_json::from_str(&content).ok();
994        Err(Error::ResponseError(ResponseContent { status, content, entity }))
995    }
996}
997
998/// Upload the client backup log file into a backup snapshot ('client.log.blob').  Permissions: Only the backup creator/owner is allowed to do this.
999pub async fn admin_datastore_create_upload_backup_log(configuration: &configuration::Configuration, store: &str, admin_datastore_create_upload_backup_log_request: models::AdminDatastoreCreateUploadBackupLogRequest) -> Result<models::AdminDatastoreCreateUploadBackupLogResponse, Error<AdminDatastoreCreateUploadBackupLogError>> {
1000    // add a prefix to parameters to efficiently prevent name collisions
1001    let p_path_store = store;
1002    let p_body_admin_datastore_create_upload_backup_log_request = admin_datastore_create_upload_backup_log_request;
1003
1004    let uri_str = format!("{}/admin/datastore/{store}/upload-backup-log", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1005    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1006
1007    if let Some(ref user_agent) = configuration.user_agent {
1008        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1009    }
1010    if let Some(ref apikey) = configuration.api_key {
1011        let key = apikey.key.clone();
1012        let value = match apikey.prefix {
1013            Some(ref prefix) => format!("{} {}", prefix, key),
1014            None => key,
1015        };
1016        req_builder = req_builder.header("Authorization", value);
1017    };
1018    if let Some(ref apikey) = configuration.api_key {
1019        let key = apikey.key.clone();
1020        let value = match apikey.prefix {
1021            Some(ref prefix) => format!("{} {}", prefix, key),
1022            None => key,
1023        };
1024        req_builder = req_builder.header("CSRFPreventionToken", value);
1025    };
1026    req_builder = req_builder.json(&p_body_admin_datastore_create_upload_backup_log_request);
1027
1028    let req = req_builder.build()?;
1029    let resp = configuration.client.execute(req).await?;
1030
1031    let status = resp.status();
1032    let content_type = resp
1033        .headers()
1034        .get("content-type")
1035        .and_then(|v| v.to_str().ok())
1036        .unwrap_or("application/octet-stream");
1037    let content_type = super::ContentType::from(content_type);
1038
1039    if !status.is_client_error() && !status.is_server_error() {
1040        let content = resp.text().await?;
1041        match content_type {
1042            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1043            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreCreateUploadBackupLogResponse`"))),
1044            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateUploadBackupLogResponse`")))),
1045        }
1046    } else {
1047        let content = resp.text().await?;
1048        let entity: Option<AdminDatastoreCreateUploadBackupLogError> = serde_json::from_str(&content).ok();
1049        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1050    }
1051}
1052
1053/// Verify backups.  This function can verify a single backup snapshot, all backups from a backup group, or all backups in the datastore.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_VERIFY for any or DATASTORE_BACKUP and being the owner of the group
1054pub async fn admin_datastore_create_verify(configuration: &configuration::Configuration, store: &str, admin_datastore_create_verify_request: Option<models::AdminDatastoreCreateVerifyRequest>) -> Result<models::AdminDatastoreCreateVerifyResponse, Error<AdminDatastoreCreateVerifyError>> {
1055    // add a prefix to parameters to efficiently prevent name collisions
1056    let p_path_store = store;
1057    let p_body_admin_datastore_create_verify_request = admin_datastore_create_verify_request;
1058
1059    let uri_str = format!("{}/admin/datastore/{store}/verify", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1060    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1061
1062    if let Some(ref user_agent) = configuration.user_agent {
1063        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1064    }
1065    if let Some(ref apikey) = configuration.api_key {
1066        let key = apikey.key.clone();
1067        let value = match apikey.prefix {
1068            Some(ref prefix) => format!("{} {}", prefix, key),
1069            None => key,
1070        };
1071        req_builder = req_builder.header("Authorization", value);
1072    };
1073    if let Some(ref apikey) = configuration.api_key {
1074        let key = apikey.key.clone();
1075        let value = match apikey.prefix {
1076            Some(ref prefix) => format!("{} {}", prefix, key),
1077            None => key,
1078        };
1079        req_builder = req_builder.header("CSRFPreventionToken", value);
1080    };
1081    req_builder = req_builder.json(&p_body_admin_datastore_create_verify_request);
1082
1083    let req = req_builder.build()?;
1084    let resp = configuration.client.execute(req).await?;
1085
1086    let status = resp.status();
1087    let content_type = resp
1088        .headers()
1089        .get("content-type")
1090        .and_then(|v| v.to_str().ok())
1091        .unwrap_or("application/octet-stream");
1092    let content_type = super::ContentType::from(content_type);
1093
1094    if !status.is_client_error() && !status.is_server_error() {
1095        let content = resp.text().await?;
1096        match content_type {
1097            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1098            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreCreateVerifyResponse`"))),
1099            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateVerifyResponse`")))),
1100        }
1101    } else {
1102        let content = resp.text().await?;
1103        let entity: Option<AdminDatastoreCreateVerifyError> = serde_json::from_str(&content).ok();
1104        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1105    }
1106}
1107
1108/// Delete backup group including all snapshots.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_MODIFY for any or DATASTORE_PRUNE and being the owner of the group
1109pub async fn admin_datastore_delete_groups(configuration: &configuration::Configuration, backup_id: &str, backup_type: models::PbsBackupTypeEnum, store: &str, error_on_protected: Option<bool>, ns: Option<&str>) -> Result<models::AdminDatastoreDeleteGroupsResponse, Error<AdminDatastoreDeleteGroupsError>> {
1110    // add a prefix to parameters to efficiently prevent name collisions
1111    let p_query_backup_id = backup_id;
1112    let p_query_backup_type = backup_type;
1113    let p_path_store = store;
1114    let p_query_error_on_protected = error_on_protected;
1115    let p_query_ns = ns;
1116
1117    let uri_str = format!("{}/admin/datastore/{store}/groups", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1118    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
1119
1120    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
1121    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
1122    if let Some(ref param_value) = p_query_error_on_protected {
1123        req_builder = req_builder.query(&[("error-on-protected", &param_value.to_string())]);
1124    }
1125    if let Some(ref param_value) = p_query_ns {
1126        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
1127    }
1128    if let Some(ref user_agent) = configuration.user_agent {
1129        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1130    }
1131    if let Some(ref apikey) = configuration.api_key {
1132        let key = apikey.key.clone();
1133        let value = match apikey.prefix {
1134            Some(ref prefix) => format!("{} {}", prefix, key),
1135            None => key,
1136        };
1137        req_builder = req_builder.header("Authorization", value);
1138    };
1139    if let Some(ref apikey) = configuration.api_key {
1140        let key = apikey.key.clone();
1141        let value = match apikey.prefix {
1142            Some(ref prefix) => format!("{} {}", prefix, key),
1143            None => key,
1144        };
1145        req_builder = req_builder.header("CSRFPreventionToken", value);
1146    };
1147
1148    let req = req_builder.build()?;
1149    let resp = configuration.client.execute(req).await?;
1150
1151    let status = resp.status();
1152    let content_type = resp
1153        .headers()
1154        .get("content-type")
1155        .and_then(|v| v.to_str().ok())
1156        .unwrap_or("application/octet-stream");
1157    let content_type = super::ContentType::from(content_type);
1158
1159    if !status.is_client_error() && !status.is_server_error() {
1160        let content = resp.text().await?;
1161        match content_type {
1162            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1163            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreDeleteGroupsResponse`"))),
1164            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreDeleteGroupsResponse`")))),
1165        }
1166    } else {
1167        let content = resp.text().await?;
1168        let entity: Option<AdminDatastoreDeleteGroupsError> = serde_json::from_str(&content).ok();
1169        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1170    }
1171}
1172
1173/// Delete a backup namespace including all snapshots.
1174pub async fn admin_datastore_delete_namespace(configuration: &configuration::Configuration, ns: &str, store: &str, delete_groups: Option<bool>, error_on_protected: Option<bool>) -> Result<models::AdminDatastoreDeleteNamespaceResponse, Error<AdminDatastoreDeleteNamespaceError>> {
1175    // add a prefix to parameters to efficiently prevent name collisions
1176    let p_query_ns = ns;
1177    let p_path_store = store;
1178    let p_query_delete_groups = delete_groups;
1179    let p_query_error_on_protected = error_on_protected;
1180
1181    let uri_str = format!("{}/admin/datastore/{store}/namespace", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1182    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
1183
1184    if let Some(ref param_value) = p_query_delete_groups {
1185        req_builder = req_builder.query(&[("delete-groups", &param_value.to_string())]);
1186    }
1187    if let Some(ref param_value) = p_query_error_on_protected {
1188        req_builder = req_builder.query(&[("error-on-protected", &param_value.to_string())]);
1189    }
1190    req_builder = req_builder.query(&[("ns", &p_query_ns.to_string())]);
1191    if let Some(ref user_agent) = configuration.user_agent {
1192        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1193    }
1194    if let Some(ref apikey) = configuration.api_key {
1195        let key = apikey.key.clone();
1196        let value = match apikey.prefix {
1197            Some(ref prefix) => format!("{} {}", prefix, key),
1198            None => key,
1199        };
1200        req_builder = req_builder.header("Authorization", value);
1201    };
1202    if let Some(ref apikey) = configuration.api_key {
1203        let key = apikey.key.clone();
1204        let value = match apikey.prefix {
1205            Some(ref prefix) => format!("{} {}", prefix, key),
1206            None => key,
1207        };
1208        req_builder = req_builder.header("CSRFPreventionToken", value);
1209    };
1210
1211    let req = req_builder.build()?;
1212    let resp = configuration.client.execute(req).await?;
1213
1214    let status = resp.status();
1215    let content_type = resp
1216        .headers()
1217        .get("content-type")
1218        .and_then(|v| v.to_str().ok())
1219        .unwrap_or("application/octet-stream");
1220    let content_type = super::ContentType::from(content_type);
1221
1222    if !status.is_client_error() && !status.is_server_error() {
1223        let content = resp.text().await?;
1224        match content_type {
1225            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1226            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreDeleteNamespaceResponse`"))),
1227            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreDeleteNamespaceResponse`")))),
1228        }
1229    } else {
1230        let content = resp.text().await?;
1231        let entity: Option<AdminDatastoreDeleteNamespaceError> = serde_json::from_str(&content).ok();
1232        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1233    }
1234}
1235
1236/// Delete backup snapshot.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_MODIFY for any or DATASTORE_PRUNE and being the owner of the group
1237pub async fn admin_datastore_delete_snapshots(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreDeleteSnapshotsResponse, Error<AdminDatastoreDeleteSnapshotsError>> {
1238    // add a prefix to parameters to efficiently prevent name collisions
1239    let p_query_backup_id = backup_id;
1240    let p_query_backup_time = backup_time;
1241    let p_query_backup_type = backup_type;
1242    let p_path_store = store;
1243    let p_query_ns = ns;
1244
1245    let uri_str = format!("{}/admin/datastore/{store}/snapshots", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1246    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
1247
1248    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
1249    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
1250    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
1251    if let Some(ref param_value) = p_query_ns {
1252        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
1253    }
1254    if let Some(ref user_agent) = configuration.user_agent {
1255        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1256    }
1257    if let Some(ref apikey) = configuration.api_key {
1258        let key = apikey.key.clone();
1259        let value = match apikey.prefix {
1260            Some(ref prefix) => format!("{} {}", prefix, key),
1261            None => key,
1262        };
1263        req_builder = req_builder.header("Authorization", value);
1264    };
1265    if let Some(ref apikey) = configuration.api_key {
1266        let key = apikey.key.clone();
1267        let value = match apikey.prefix {
1268            Some(ref prefix) => format!("{} {}", prefix, key),
1269            None => key,
1270        };
1271        req_builder = req_builder.header("CSRFPreventionToken", value);
1272    };
1273
1274    let req = req_builder.build()?;
1275    let resp = configuration.client.execute(req).await?;
1276
1277    let status = resp.status();
1278    let content_type = resp
1279        .headers()
1280        .get("content-type")
1281        .and_then(|v| v.to_str().ok())
1282        .unwrap_or("application/octet-stream");
1283    let content_type = super::ContentType::from(content_type);
1284
1285    if !status.is_client_error() && !status.is_server_error() {
1286        let content = resp.text().await?;
1287        match content_type {
1288            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1289            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreDeleteSnapshotsResponse`"))),
1290            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreDeleteSnapshotsResponse`")))),
1291        }
1292    } else {
1293        let content = resp.text().await?;
1294        let entity: Option<AdminDatastoreDeleteSnapshotsError> = serde_json::from_str(&content).ok();
1295        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1296    }
1297}
1298
1299/// Read datastore stats
1300pub async fn admin_datastore_get_active_operations(configuration: &configuration::Configuration, store: &str) -> Result<models::AdminDatastoreGetActiveOperationsResponse, Error<AdminDatastoreGetActiveOperationsError>> {
1301    // add a prefix to parameters to efficiently prevent name collisions
1302    let p_path_store = store;
1303
1304    let uri_str = format!("{}/admin/datastore/{store}/active-operations", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1305    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1306
1307    if let Some(ref user_agent) = configuration.user_agent {
1308        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1309    }
1310    if let Some(ref apikey) = configuration.api_key {
1311        let key = apikey.key.clone();
1312        let value = match apikey.prefix {
1313            Some(ref prefix) => format!("{} {}", prefix, key),
1314            None => key,
1315        };
1316        req_builder = req_builder.header("Authorization", value);
1317    };
1318    if let Some(ref apikey) = configuration.api_key {
1319        let key = apikey.key.clone();
1320        let value = match apikey.prefix {
1321            Some(ref prefix) => format!("{} {}", prefix, key),
1322            None => key,
1323        };
1324        req_builder = req_builder.header("CSRFPreventionToken", value);
1325    };
1326
1327    let req = req_builder.build()?;
1328    let resp = configuration.client.execute(req).await?;
1329
1330    let status = resp.status();
1331    let content_type = resp
1332        .headers()
1333        .get("content-type")
1334        .and_then(|v| v.to_str().ok())
1335        .unwrap_or("application/octet-stream");
1336    let content_type = super::ContentType::from(content_type);
1337
1338    if !status.is_client_error() && !status.is_server_error() {
1339        let content = resp.text().await?;
1340        match content_type {
1341            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1342            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetActiveOperationsResponse`"))),
1343            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetActiveOperationsResponse`")))),
1344        }
1345    } else {
1346        let content = resp.text().await?;
1347        let entity: Option<AdminDatastoreGetActiveOperationsError> = serde_json::from_str(&content).ok();
1348        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1349    }
1350}
1351
1352/// Directory index.
1353pub async fn admin_datastore_get_admin_datastore_by_store(configuration: &configuration::Configuration, store: &str) -> Result<models::AdminDatastoreGetAdminDatastoreByStoreResponse, Error<AdminDatastoreGetAdminDatastoreByStoreError>> {
1354    // add a prefix to parameters to efficiently prevent name collisions
1355    let p_path_store = store;
1356
1357    let uri_str = format!("{}/admin/datastore/{store}", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1358    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1359
1360    if let Some(ref user_agent) = configuration.user_agent {
1361        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1362    }
1363    if let Some(ref apikey) = configuration.api_key {
1364        let key = apikey.key.clone();
1365        let value = match apikey.prefix {
1366            Some(ref prefix) => format!("{} {}", prefix, key),
1367            None => key,
1368        };
1369        req_builder = req_builder.header("Authorization", value);
1370    };
1371    if let Some(ref apikey) = configuration.api_key {
1372        let key = apikey.key.clone();
1373        let value = match apikey.prefix {
1374            Some(ref prefix) => format!("{} {}", prefix, key),
1375            None => key,
1376        };
1377        req_builder = req_builder.header("CSRFPreventionToken", value);
1378    };
1379
1380    let req = req_builder.build()?;
1381    let resp = configuration.client.execute(req).await?;
1382
1383    let status = resp.status();
1384    let content_type = resp
1385        .headers()
1386        .get("content-type")
1387        .and_then(|v| v.to_str().ok())
1388        .unwrap_or("application/octet-stream");
1389    let content_type = super::ContentType::from(content_type);
1390
1391    if !status.is_client_error() && !status.is_server_error() {
1392        let content = resp.text().await?;
1393        match content_type {
1394            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1395            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetAdminDatastoreByStoreResponse`"))),
1396            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetAdminDatastoreByStoreResponse`")))),
1397        }
1398    } else {
1399        let content = resp.text().await?;
1400        let entity: Option<AdminDatastoreGetAdminDatastoreByStoreError> = serde_json::from_str(&content).ok();
1401        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1402    }
1403}
1404
1405/// Get the entries of the given path of the catalog  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_READ for any or DATASTORE_BACKUP and being the owner of the group
1406pub async fn admin_datastore_get_catalog(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, filepath: &str, store: &str, archive_name: Option<&str>, ns: Option<&str>) -> Result<models::AdminDatastoreGetCatalogResponse, Error<AdminDatastoreGetCatalogError>> {
1407    // add a prefix to parameters to efficiently prevent name collisions
1408    let p_query_backup_id = backup_id;
1409    let p_query_backup_time = backup_time;
1410    let p_query_backup_type = backup_type;
1411    let p_query_filepath = filepath;
1412    let p_path_store = store;
1413    let p_query_archive_name = archive_name;
1414    let p_query_ns = ns;
1415
1416    let uri_str = format!("{}/admin/datastore/{store}/catalog", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1417    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1418
1419    if let Some(ref param_value) = p_query_archive_name {
1420        req_builder = req_builder.query(&[("archive-name", &param_value.to_string())]);
1421    }
1422    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
1423    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
1424    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
1425    req_builder = req_builder.query(&[("filepath", &p_query_filepath.to_string())]);
1426    if let Some(ref param_value) = p_query_ns {
1427        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
1428    }
1429    if let Some(ref user_agent) = configuration.user_agent {
1430        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1431    }
1432    if let Some(ref apikey) = configuration.api_key {
1433        let key = apikey.key.clone();
1434        let value = match apikey.prefix {
1435            Some(ref prefix) => format!("{} {}", prefix, key),
1436            None => key,
1437        };
1438        req_builder = req_builder.header("Authorization", value);
1439    };
1440    if let Some(ref apikey) = configuration.api_key {
1441        let key = apikey.key.clone();
1442        let value = match apikey.prefix {
1443            Some(ref prefix) => format!("{} {}", prefix, key),
1444            None => key,
1445        };
1446        req_builder = req_builder.header("CSRFPreventionToken", value);
1447    };
1448
1449    let req = req_builder.build()?;
1450    let resp = configuration.client.execute(req).await?;
1451
1452    let status = resp.status();
1453    let content_type = resp
1454        .headers()
1455        .get("content-type")
1456        .and_then(|v| v.to_str().ok())
1457        .unwrap_or("application/octet-stream");
1458    let content_type = super::ContentType::from(content_type);
1459
1460    if !status.is_client_error() && !status.is_server_error() {
1461        let content = resp.text().await?;
1462        match content_type {
1463            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1464            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetCatalogResponse`"))),
1465            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetCatalogResponse`")))),
1466        }
1467    } else {
1468        let content = resp.text().await?;
1469        let entity: Option<AdminDatastoreGetCatalogError> = serde_json::from_str(&content).ok();
1470        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1471    }
1472}
1473
1474/// Datastore list
1475pub async fn admin_datastore_get_datastore(configuration: &configuration::Configuration, ) -> Result<models::AdminDatastoreGetDatastoreResponse, Error<AdminDatastoreGetDatastoreError>> {
1476
1477    let uri_str = format!("{}/admin/datastore", configuration.base_path);
1478    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1479
1480    if let Some(ref user_agent) = configuration.user_agent {
1481        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1482    }
1483    if let Some(ref apikey) = configuration.api_key {
1484        let key = apikey.key.clone();
1485        let value = match apikey.prefix {
1486            Some(ref prefix) => format!("{} {}", prefix, key),
1487            None => key,
1488        };
1489        req_builder = req_builder.header("Authorization", value);
1490    };
1491    if let Some(ref apikey) = configuration.api_key {
1492        let key = apikey.key.clone();
1493        let value = match apikey.prefix {
1494            Some(ref prefix) => format!("{} {}", prefix, key),
1495            None => key,
1496        };
1497        req_builder = req_builder.header("CSRFPreventionToken", value);
1498    };
1499
1500    let req = req_builder.build()?;
1501    let resp = configuration.client.execute(req).await?;
1502
1503    let status = resp.status();
1504    let content_type = resp
1505        .headers()
1506        .get("content-type")
1507        .and_then(|v| v.to_str().ok())
1508        .unwrap_or("application/octet-stream");
1509    let content_type = super::ContentType::from(content_type);
1510
1511    if !status.is_client_error() && !status.is_server_error() {
1512        let content = resp.text().await?;
1513        match content_type {
1514            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1515            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetDatastoreResponse`"))),
1516            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetDatastoreResponse`")))),
1517        }
1518    } else {
1519        let content = resp.text().await?;
1520        let entity: Option<AdminDatastoreGetDatastoreError> = serde_json::from_str(&content).ok();
1521        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1522    }
1523}
1524
1525/// Download single raw file from backup snapshot.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_READ for any or DATASTORE_BACKUP and being the owner of the group
1526pub async fn admin_datastore_get_download(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, file_name: &str, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreGetDownloadResponse, Error<AdminDatastoreGetDownloadError>> {
1527    // add a prefix to parameters to efficiently prevent name collisions
1528    let p_query_backup_id = backup_id;
1529    let p_query_backup_time = backup_time;
1530    let p_query_backup_type = backup_type;
1531    let p_query_file_name = file_name;
1532    let p_path_store = store;
1533    let p_query_ns = ns;
1534
1535    let uri_str = format!("{}/admin/datastore/{store}/download", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1536    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1537
1538    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
1539    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
1540    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
1541    req_builder = req_builder.query(&[("file-name", &p_query_file_name.to_string())]);
1542    if let Some(ref param_value) = p_query_ns {
1543        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
1544    }
1545    if let Some(ref user_agent) = configuration.user_agent {
1546        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1547    }
1548    if let Some(ref apikey) = configuration.api_key {
1549        let key = apikey.key.clone();
1550        let value = match apikey.prefix {
1551            Some(ref prefix) => format!("{} {}", prefix, key),
1552            None => key,
1553        };
1554        req_builder = req_builder.header("Authorization", value);
1555    };
1556    if let Some(ref apikey) = configuration.api_key {
1557        let key = apikey.key.clone();
1558        let value = match apikey.prefix {
1559            Some(ref prefix) => format!("{} {}", prefix, key),
1560            None => key,
1561        };
1562        req_builder = req_builder.header("CSRFPreventionToken", value);
1563    };
1564
1565    let req = req_builder.build()?;
1566    let resp = configuration.client.execute(req).await?;
1567
1568    let status = resp.status();
1569    let content_type = resp
1570        .headers()
1571        .get("content-type")
1572        .and_then(|v| v.to_str().ok())
1573        .unwrap_or("application/octet-stream");
1574    let content_type = super::ContentType::from(content_type);
1575
1576    if !status.is_client_error() && !status.is_server_error() {
1577        let content = resp.text().await?;
1578        match content_type {
1579            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1580            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetDownloadResponse`"))),
1581            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetDownloadResponse`")))),
1582        }
1583    } else {
1584        let content = resp.text().await?;
1585        let entity: Option<AdminDatastoreGetDownloadError> = serde_json::from_str(&content).ok();
1586        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1587    }
1588}
1589
1590/// Download single decoded file from backup snapshot. Only works if it's not encrypted.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_READ for any or DATASTORE_BACKUP and being the owner of the group
1591pub async fn admin_datastore_get_download_decoded(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, file_name: &str, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreGetDownloadDecodedResponse, Error<AdminDatastoreGetDownloadDecodedError>> {
1592    // add a prefix to parameters to efficiently prevent name collisions
1593    let p_query_backup_id = backup_id;
1594    let p_query_backup_time = backup_time;
1595    let p_query_backup_type = backup_type;
1596    let p_query_file_name = file_name;
1597    let p_path_store = store;
1598    let p_query_ns = ns;
1599
1600    let uri_str = format!("{}/admin/datastore/{store}/download-decoded", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1601    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1602
1603    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
1604    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
1605    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
1606    req_builder = req_builder.query(&[("file-name", &p_query_file_name.to_string())]);
1607    if let Some(ref param_value) = p_query_ns {
1608        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
1609    }
1610    if let Some(ref user_agent) = configuration.user_agent {
1611        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1612    }
1613    if let Some(ref apikey) = configuration.api_key {
1614        let key = apikey.key.clone();
1615        let value = match apikey.prefix {
1616            Some(ref prefix) => format!("{} {}", prefix, key),
1617            None => key,
1618        };
1619        req_builder = req_builder.header("Authorization", value);
1620    };
1621    if let Some(ref apikey) = configuration.api_key {
1622        let key = apikey.key.clone();
1623        let value = match apikey.prefix {
1624            Some(ref prefix) => format!("{} {}", prefix, key),
1625            None => key,
1626        };
1627        req_builder = req_builder.header("CSRFPreventionToken", value);
1628    };
1629
1630    let req = req_builder.build()?;
1631    let resp = configuration.client.execute(req).await?;
1632
1633    let status = resp.status();
1634    let content_type = resp
1635        .headers()
1636        .get("content-type")
1637        .and_then(|v| v.to_str().ok())
1638        .unwrap_or("application/octet-stream");
1639    let content_type = super::ContentType::from(content_type);
1640
1641    if !status.is_client_error() && !status.is_server_error() {
1642        let content = resp.text().await?;
1643        match content_type {
1644            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1645            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetDownloadDecodedResponse`"))),
1646            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetDownloadDecodedResponse`")))),
1647        }
1648    } else {
1649        let content = resp.text().await?;
1650        let entity: Option<AdminDatastoreGetDownloadDecodedError> = serde_json::from_str(&content).ok();
1651        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1652    }
1653}
1654
1655/// List snapshot files.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_AUDIT or DATASTORE_READ for any or DATASTORE_BACKUP and being the owner of the group
1656pub async fn admin_datastore_get_files(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreGetFilesResponse, Error<AdminDatastoreGetFilesError>> {
1657    // add a prefix to parameters to efficiently prevent name collisions
1658    let p_query_backup_id = backup_id;
1659    let p_query_backup_time = backup_time;
1660    let p_query_backup_type = backup_type;
1661    let p_path_store = store;
1662    let p_query_ns = ns;
1663
1664    let uri_str = format!("{}/admin/datastore/{store}/files", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1665    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1666
1667    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
1668    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
1669    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
1670    if let Some(ref param_value) = p_query_ns {
1671        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
1672    }
1673    if let Some(ref user_agent) = configuration.user_agent {
1674        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1675    }
1676    if let Some(ref apikey) = configuration.api_key {
1677        let key = apikey.key.clone();
1678        let value = match apikey.prefix {
1679            Some(ref prefix) => format!("{} {}", prefix, key),
1680            None => key,
1681        };
1682        req_builder = req_builder.header("Authorization", value);
1683    };
1684    if let Some(ref apikey) = configuration.api_key {
1685        let key = apikey.key.clone();
1686        let value = match apikey.prefix {
1687            Some(ref prefix) => format!("{} {}", prefix, key),
1688            None => key,
1689        };
1690        req_builder = req_builder.header("CSRFPreventionToken", value);
1691    };
1692
1693    let req = req_builder.build()?;
1694    let resp = configuration.client.execute(req).await?;
1695
1696    let status = resp.status();
1697    let content_type = resp
1698        .headers()
1699        .get("content-type")
1700        .and_then(|v| v.to_str().ok())
1701        .unwrap_or("application/octet-stream");
1702    let content_type = super::ContentType::from(content_type);
1703
1704    if !status.is_client_error() && !status.is_server_error() {
1705        let content = resp.text().await?;
1706        match content_type {
1707            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1708            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetFilesResponse`"))),
1709            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetFilesResponse`")))),
1710        }
1711    } else {
1712        let content = resp.text().await?;
1713        let entity: Option<AdminDatastoreGetFilesError> = serde_json::from_str(&content).ok();
1714        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1715    }
1716}
1717
1718/// Garbage collection status.
1719pub async fn admin_datastore_get_gc(configuration: &configuration::Configuration, store: &str) -> Result<models::AdminDatastoreGetGcResponse, Error<AdminDatastoreGetGcError>> {
1720    // add a prefix to parameters to efficiently prevent name collisions
1721    let p_path_store = store;
1722
1723    let uri_str = format!("{}/admin/datastore/{store}/gc", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1724    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1725
1726    if let Some(ref user_agent) = configuration.user_agent {
1727        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1728    }
1729    if let Some(ref apikey) = configuration.api_key {
1730        let key = apikey.key.clone();
1731        let value = match apikey.prefix {
1732            Some(ref prefix) => format!("{} {}", prefix, key),
1733            None => key,
1734        };
1735        req_builder = req_builder.header("Authorization", value);
1736    };
1737    if let Some(ref apikey) = configuration.api_key {
1738        let key = apikey.key.clone();
1739        let value = match apikey.prefix {
1740            Some(ref prefix) => format!("{} {}", prefix, key),
1741            None => key,
1742        };
1743        req_builder = req_builder.header("CSRFPreventionToken", value);
1744    };
1745
1746    let req = req_builder.build()?;
1747    let resp = configuration.client.execute(req).await?;
1748
1749    let status = resp.status();
1750    let content_type = resp
1751        .headers()
1752        .get("content-type")
1753        .and_then(|v| v.to_str().ok())
1754        .unwrap_or("application/octet-stream");
1755    let content_type = super::ContentType::from(content_type);
1756
1757    if !status.is_client_error() && !status.is_server_error() {
1758        let content = resp.text().await?;
1759        match content_type {
1760            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1761            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetGcResponse`"))),
1762            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetGcResponse`")))),
1763        }
1764    } else {
1765        let content = resp.text().await?;
1766        let entity: Option<AdminDatastoreGetGcError> = serde_json::from_str(&content).ok();
1767        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1768    }
1769}
1770
1771/// Get \"notes\" for a backup group  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_AUDIT for any or DATASTORE_BACKUP and being the owner of the group
1772pub async fn admin_datastore_get_group_notes(configuration: &configuration::Configuration, backup_id: &str, backup_type: models::PbsBackupTypeEnum, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreGetGroupNotesResponse, Error<AdminDatastoreGetGroupNotesError>> {
1773    // add a prefix to parameters to efficiently prevent name collisions
1774    let p_query_backup_id = backup_id;
1775    let p_query_backup_type = backup_type;
1776    let p_path_store = store;
1777    let p_query_ns = ns;
1778
1779    let uri_str = format!("{}/admin/datastore/{store}/group-notes", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1780    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1781
1782    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
1783    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
1784    if let Some(ref param_value) = p_query_ns {
1785        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
1786    }
1787    if let Some(ref user_agent) = configuration.user_agent {
1788        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1789    }
1790    if let Some(ref apikey) = configuration.api_key {
1791        let key = apikey.key.clone();
1792        let value = match apikey.prefix {
1793            Some(ref prefix) => format!("{} {}", prefix, key),
1794            None => key,
1795        };
1796        req_builder = req_builder.header("Authorization", value);
1797    };
1798    if let Some(ref apikey) = configuration.api_key {
1799        let key = apikey.key.clone();
1800        let value = match apikey.prefix {
1801            Some(ref prefix) => format!("{} {}", prefix, key),
1802            None => key,
1803        };
1804        req_builder = req_builder.header("CSRFPreventionToken", value);
1805    };
1806
1807    let req = req_builder.build()?;
1808    let resp = configuration.client.execute(req).await?;
1809
1810    let status = resp.status();
1811    let content_type = resp
1812        .headers()
1813        .get("content-type")
1814        .and_then(|v| v.to_str().ok())
1815        .unwrap_or("application/octet-stream");
1816    let content_type = super::ContentType::from(content_type);
1817
1818    if !status.is_client_error() && !status.is_server_error() {
1819        let content = resp.text().await?;
1820        match content_type {
1821            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1822            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetGroupNotesResponse`"))),
1823            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetGroupNotesResponse`")))),
1824        }
1825    } else {
1826        let content = resp.text().await?;
1827        let entity: Option<AdminDatastoreGetGroupNotesError> = serde_json::from_str(&content).ok();
1828        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1829    }
1830}
1831
1832/// List backup groups.  Permissions: Requires DATASTORE_AUDIT for all or DATASTORE_BACKUP for owned groups on /datastore/{store}[/{namespace}]
1833pub async fn admin_datastore_get_groups(configuration: &configuration::Configuration, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreGetGroupsResponse, Error<AdminDatastoreGetGroupsError>> {
1834    // add a prefix to parameters to efficiently prevent name collisions
1835    let p_path_store = store;
1836    let p_query_ns = ns;
1837
1838    let uri_str = format!("{}/admin/datastore/{store}/groups", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1839    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1840
1841    if let Some(ref param_value) = p_query_ns {
1842        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
1843    }
1844    if let Some(ref user_agent) = configuration.user_agent {
1845        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1846    }
1847    if let Some(ref apikey) = configuration.api_key {
1848        let key = apikey.key.clone();
1849        let value = match apikey.prefix {
1850            Some(ref prefix) => format!("{} {}", prefix, key),
1851            None => key,
1852        };
1853        req_builder = req_builder.header("Authorization", value);
1854    };
1855    if let Some(ref apikey) = configuration.api_key {
1856        let key = apikey.key.clone();
1857        let value = match apikey.prefix {
1858            Some(ref prefix) => format!("{} {}", prefix, key),
1859            None => key,
1860        };
1861        req_builder = req_builder.header("CSRFPreventionToken", value);
1862    };
1863
1864    let req = req_builder.build()?;
1865    let resp = configuration.client.execute(req).await?;
1866
1867    let status = resp.status();
1868    let content_type = resp
1869        .headers()
1870        .get("content-type")
1871        .and_then(|v| v.to_str().ok())
1872        .unwrap_or("application/octet-stream");
1873    let content_type = super::ContentType::from(content_type);
1874
1875    if !status.is_client_error() && !status.is_server_error() {
1876        let content = resp.text().await?;
1877        match content_type {
1878            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1879            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetGroupsResponse`"))),
1880            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetGroupsResponse`")))),
1881        }
1882    } else {
1883        let content = resp.text().await?;
1884        let entity: Option<AdminDatastoreGetGroupsError> = serde_json::from_str(&content).ok();
1885        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1886    }
1887}
1888
1889/// List the namespaces of a datastore.  Permissions: Requires DATASTORE_AUDIT, DATASTORE_MODIFY or DATASTORE_BACKUP /datastore/{store}[/{parent}]
1890pub async fn admin_datastore_get_namespace(configuration: &configuration::Configuration, store: &str, max_depth: Option<i32>, parent: Option<&str>) -> Result<models::AdminDatastoreGetNamespaceResponse, Error<AdminDatastoreGetNamespaceError>> {
1891    // add a prefix to parameters to efficiently prevent name collisions
1892    let p_path_store = store;
1893    let p_query_max_depth = max_depth;
1894    let p_query_parent = parent;
1895
1896    let uri_str = format!("{}/admin/datastore/{store}/namespace", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1897    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1898
1899    if let Some(ref param_value) = p_query_max_depth {
1900        req_builder = req_builder.query(&[("max-depth", &param_value.to_string())]);
1901    }
1902    if let Some(ref param_value) = p_query_parent {
1903        req_builder = req_builder.query(&[("parent", &param_value.to_string())]);
1904    }
1905    if let Some(ref user_agent) = configuration.user_agent {
1906        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1907    }
1908    if let Some(ref apikey) = configuration.api_key {
1909        let key = apikey.key.clone();
1910        let value = match apikey.prefix {
1911            Some(ref prefix) => format!("{} {}", prefix, key),
1912            None => key,
1913        };
1914        req_builder = req_builder.header("Authorization", value);
1915    };
1916    if let Some(ref apikey) = configuration.api_key {
1917        let key = apikey.key.clone();
1918        let value = match apikey.prefix {
1919            Some(ref prefix) => format!("{} {}", prefix, key),
1920            None => key,
1921        };
1922        req_builder = req_builder.header("CSRFPreventionToken", value);
1923    };
1924
1925    let req = req_builder.build()?;
1926    let resp = configuration.client.execute(req).await?;
1927
1928    let status = resp.status();
1929    let content_type = resp
1930        .headers()
1931        .get("content-type")
1932        .and_then(|v| v.to_str().ok())
1933        .unwrap_or("application/octet-stream");
1934    let content_type = super::ContentType::from(content_type);
1935
1936    if !status.is_client_error() && !status.is_server_error() {
1937        let content = resp.text().await?;
1938        match content_type {
1939            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1940            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetNamespaceResponse`"))),
1941            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetNamespaceResponse`")))),
1942        }
1943    } else {
1944        let content = resp.text().await?;
1945        let entity: Option<AdminDatastoreGetNamespaceError> = serde_json::from_str(&content).ok();
1946        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1947    }
1948}
1949
1950/// Get \"notes\" for a specific backup  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_AUDIT for any or DATASTORE_BACKUP and being the owner of the group
1951pub async fn admin_datastore_get_notes(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreGetNotesResponse, Error<AdminDatastoreGetNotesError>> {
1952    // add a prefix to parameters to efficiently prevent name collisions
1953    let p_query_backup_id = backup_id;
1954    let p_query_backup_time = backup_time;
1955    let p_query_backup_type = backup_type;
1956    let p_path_store = store;
1957    let p_query_ns = ns;
1958
1959    let uri_str = format!("{}/admin/datastore/{store}/notes", configuration.base_path, store=crate::apis::urlencode(p_path_store));
1960    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1961
1962    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
1963    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
1964    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
1965    if let Some(ref param_value) = p_query_ns {
1966        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
1967    }
1968    if let Some(ref user_agent) = configuration.user_agent {
1969        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1970    }
1971    if let Some(ref apikey) = configuration.api_key {
1972        let key = apikey.key.clone();
1973        let value = match apikey.prefix {
1974            Some(ref prefix) => format!("{} {}", prefix, key),
1975            None => key,
1976        };
1977        req_builder = req_builder.header("Authorization", value);
1978    };
1979    if let Some(ref apikey) = configuration.api_key {
1980        let key = apikey.key.clone();
1981        let value = match apikey.prefix {
1982            Some(ref prefix) => format!("{} {}", prefix, key),
1983            None => key,
1984        };
1985        req_builder = req_builder.header("CSRFPreventionToken", value);
1986    };
1987
1988    let req = req_builder.build()?;
1989    let resp = configuration.client.execute(req).await?;
1990
1991    let status = resp.status();
1992    let content_type = resp
1993        .headers()
1994        .get("content-type")
1995        .and_then(|v| v.to_str().ok())
1996        .unwrap_or("application/octet-stream");
1997    let content_type = super::ContentType::from(content_type);
1998
1999    if !status.is_client_error() && !status.is_server_error() {
2000        let content = resp.text().await?;
2001        match content_type {
2002            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2003            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetNotesResponse`"))),
2004            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetNotesResponse`")))),
2005        }
2006    } else {
2007        let content = resp.text().await?;
2008        let entity: Option<AdminDatastoreGetNotesError> = serde_json::from_str(&content).ok();
2009        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2010    }
2011}
2012
2013/// Query protection for a specific backup  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_AUDIT for any or DATASTORE_BACKUP and being the owner of the group
2014pub async fn admin_datastore_get_protected(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreGetProtectedResponse, Error<AdminDatastoreGetProtectedError>> {
2015    // add a prefix to parameters to efficiently prevent name collisions
2016    let p_query_backup_id = backup_id;
2017    let p_query_backup_time = backup_time;
2018    let p_query_backup_type = backup_type;
2019    let p_path_store = store;
2020    let p_query_ns = ns;
2021
2022    let uri_str = format!("{}/admin/datastore/{store}/protected", configuration.base_path, store=crate::apis::urlencode(p_path_store));
2023    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2024
2025    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
2026    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
2027    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
2028    if let Some(ref param_value) = p_query_ns {
2029        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
2030    }
2031    if let Some(ref user_agent) = configuration.user_agent {
2032        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2033    }
2034    if let Some(ref apikey) = configuration.api_key {
2035        let key = apikey.key.clone();
2036        let value = match apikey.prefix {
2037            Some(ref prefix) => format!("{} {}", prefix, key),
2038            None => key,
2039        };
2040        req_builder = req_builder.header("Authorization", value);
2041    };
2042    if let Some(ref apikey) = configuration.api_key {
2043        let key = apikey.key.clone();
2044        let value = match apikey.prefix {
2045            Some(ref prefix) => format!("{} {}", prefix, key),
2046            None => key,
2047        };
2048        req_builder = req_builder.header("CSRFPreventionToken", value);
2049    };
2050
2051    let req = req_builder.build()?;
2052    let resp = configuration.client.execute(req).await?;
2053
2054    let status = resp.status();
2055    let content_type = resp
2056        .headers()
2057        .get("content-type")
2058        .and_then(|v| v.to_str().ok())
2059        .unwrap_or("application/octet-stream");
2060    let content_type = super::ContentType::from(content_type);
2061
2062    if !status.is_client_error() && !status.is_server_error() {
2063        let content = resp.text().await?;
2064        match content_type {
2065            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2066            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetProtectedResponse`"))),
2067            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetProtectedResponse`")))),
2068        }
2069    } else {
2070        let content = resp.text().await?;
2071        let entity: Option<AdminDatastoreGetProtectedError> = serde_json::from_str(&content).ok();
2072        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2073    }
2074}
2075
2076/// Download single file from pxar file of a backup snapshot. Only works if it's not encrypted.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_READ for any or DATASTORE_BACKUP and being the owner of the group
2077pub async fn admin_datastore_get_pxar_file_download(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, filepath: &str, store: &str, archive_name: Option<&str>, ns: Option<&str>, tar: Option<bool>) -> Result<models::AdminDatastoreGetPxarFileDownloadResponse, Error<AdminDatastoreGetPxarFileDownloadError>> {
2078    // add a prefix to parameters to efficiently prevent name collisions
2079    let p_query_backup_id = backup_id;
2080    let p_query_backup_time = backup_time;
2081    let p_query_backup_type = backup_type;
2082    let p_query_filepath = filepath;
2083    let p_path_store = store;
2084    let p_query_archive_name = archive_name;
2085    let p_query_ns = ns;
2086    let p_query_tar = tar;
2087
2088    let uri_str = format!("{}/admin/datastore/{store}/pxar-file-download", configuration.base_path, store=crate::apis::urlencode(p_path_store));
2089    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2090
2091    if let Some(ref param_value) = p_query_archive_name {
2092        req_builder = req_builder.query(&[("archive-name", &param_value.to_string())]);
2093    }
2094    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
2095    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
2096    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
2097    req_builder = req_builder.query(&[("filepath", &p_query_filepath.to_string())]);
2098    if let Some(ref param_value) = p_query_ns {
2099        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
2100    }
2101    if let Some(ref param_value) = p_query_tar {
2102        req_builder = req_builder.query(&[("tar", &param_value.to_string())]);
2103    }
2104    if let Some(ref user_agent) = configuration.user_agent {
2105        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2106    }
2107    if let Some(ref apikey) = configuration.api_key {
2108        let key = apikey.key.clone();
2109        let value = match apikey.prefix {
2110            Some(ref prefix) => format!("{} {}", prefix, key),
2111            None => key,
2112        };
2113        req_builder = req_builder.header("Authorization", value);
2114    };
2115    if let Some(ref apikey) = configuration.api_key {
2116        let key = apikey.key.clone();
2117        let value = match apikey.prefix {
2118            Some(ref prefix) => format!("{} {}", prefix, key),
2119            None => key,
2120        };
2121        req_builder = req_builder.header("CSRFPreventionToken", value);
2122    };
2123
2124    let req = req_builder.build()?;
2125    let resp = configuration.client.execute(req).await?;
2126
2127    let status = resp.status();
2128    let content_type = resp
2129        .headers()
2130        .get("content-type")
2131        .and_then(|v| v.to_str().ok())
2132        .unwrap_or("application/octet-stream");
2133    let content_type = super::ContentType::from(content_type);
2134
2135    if !status.is_client_error() && !status.is_server_error() {
2136        let content = resp.text().await?;
2137        match content_type {
2138            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2139            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetPxarFileDownloadResponse`"))),
2140            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetPxarFileDownloadResponse`")))),
2141        }
2142    } else {
2143        let content = resp.text().await?;
2144        let entity: Option<AdminDatastoreGetPxarFileDownloadError> = serde_json::from_str(&content).ok();
2145        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2146    }
2147}
2148
2149/// Read datastore stats
2150pub async fn admin_datastore_get_rrd(configuration: &configuration::Configuration, cf: models::PbsCfEnum, store: &str, timeframe: models::PbsTimeframeEnum) -> Result<models::AdminDatastoreGetRrdResponse, Error<AdminDatastoreGetRrdError>> {
2151    // add a prefix to parameters to efficiently prevent name collisions
2152    let p_query_cf = cf;
2153    let p_path_store = store;
2154    let p_query_timeframe = timeframe;
2155
2156    let uri_str = format!("{}/admin/datastore/{store}/rrd", configuration.base_path, store=crate::apis::urlencode(p_path_store));
2157    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2158
2159    req_builder = req_builder.query(&[("cf", &p_query_cf.to_string())]);
2160    req_builder = req_builder.query(&[("timeframe", &p_query_timeframe.to_string())]);
2161    if let Some(ref user_agent) = configuration.user_agent {
2162        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2163    }
2164    if let Some(ref apikey) = configuration.api_key {
2165        let key = apikey.key.clone();
2166        let value = match apikey.prefix {
2167            Some(ref prefix) => format!("{} {}", prefix, key),
2168            None => key,
2169        };
2170        req_builder = req_builder.header("Authorization", value);
2171    };
2172    if let Some(ref apikey) = configuration.api_key {
2173        let key = apikey.key.clone();
2174        let value = match apikey.prefix {
2175            Some(ref prefix) => format!("{} {}", prefix, key),
2176            None => key,
2177        };
2178        req_builder = req_builder.header("CSRFPreventionToken", value);
2179    };
2180
2181    let req = req_builder.build()?;
2182    let resp = configuration.client.execute(req).await?;
2183
2184    let status = resp.status();
2185    let content_type = resp
2186        .headers()
2187        .get("content-type")
2188        .and_then(|v| v.to_str().ok())
2189        .unwrap_or("application/octet-stream");
2190    let content_type = super::ContentType::from(content_type);
2191
2192    if !status.is_client_error() && !status.is_server_error() {
2193        let content = resp.text().await?;
2194        match content_type {
2195            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2196            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetRrdResponse`"))),
2197            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetRrdResponse`")))),
2198        }
2199    } else {
2200        let content = resp.text().await?;
2201        let entity: Option<AdminDatastoreGetRrdError> = serde_json::from_str(&content).ok();
2202        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2203    }
2204}
2205
2206/// List backup snapshots.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_AUDIT for any or DATASTORE_BACKUP and being the owner of the group
2207pub async fn admin_datastore_get_snapshots(configuration: &configuration::Configuration, store: &str, backup_id: Option<&str>, backup_type: Option<models::PbsBackupTypeEnum>, ns: Option<&str>) -> Result<models::AdminDatastoreGetSnapshotsResponse, Error<AdminDatastoreGetSnapshotsError>> {
2208    // add a prefix to parameters to efficiently prevent name collisions
2209    let p_path_store = store;
2210    let p_query_backup_id = backup_id;
2211    let p_query_backup_type = backup_type;
2212    let p_query_ns = ns;
2213
2214    let uri_str = format!("{}/admin/datastore/{store}/snapshots", configuration.base_path, store=crate::apis::urlencode(p_path_store));
2215    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2216
2217    if let Some(ref param_value) = p_query_backup_id {
2218        req_builder = req_builder.query(&[("backup-id", &param_value.to_string())]);
2219    }
2220    if let Some(ref param_value) = p_query_backup_type {
2221        req_builder = req_builder.query(&[("backup-type", &param_value.to_string())]);
2222    }
2223    if let Some(ref param_value) = p_query_ns {
2224        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
2225    }
2226    if let Some(ref user_agent) = configuration.user_agent {
2227        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2228    }
2229    if let Some(ref apikey) = configuration.api_key {
2230        let key = apikey.key.clone();
2231        let value = match apikey.prefix {
2232            Some(ref prefix) => format!("{} {}", prefix, key),
2233            None => key,
2234        };
2235        req_builder = req_builder.header("Authorization", value);
2236    };
2237    if let Some(ref apikey) = configuration.api_key {
2238        let key = apikey.key.clone();
2239        let value = match apikey.prefix {
2240            Some(ref prefix) => format!("{} {}", prefix, key),
2241            None => key,
2242        };
2243        req_builder = req_builder.header("CSRFPreventionToken", value);
2244    };
2245
2246    let req = req_builder.build()?;
2247    let resp = configuration.client.execute(req).await?;
2248
2249    let status = resp.status();
2250    let content_type = resp
2251        .headers()
2252        .get("content-type")
2253        .and_then(|v| v.to_str().ok())
2254        .unwrap_or("application/octet-stream");
2255    let content_type = super::ContentType::from(content_type);
2256
2257    if !status.is_client_error() && !status.is_server_error() {
2258        let content = resp.text().await?;
2259        match content_type {
2260            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2261            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetSnapshotsResponse`"))),
2262            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetSnapshotsResponse`")))),
2263        }
2264    } else {
2265        let content = resp.text().await?;
2266        let entity: Option<AdminDatastoreGetSnapshotsError> = serde_json::from_str(&content).ok();
2267        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2268    }
2269}
2270
2271/// Get datastore status.  Permissions: Requires on /datastore/{store} either DATASTORE_AUDIT or DATASTORE_BACKUP for the full statistics. Counts of accessible groups are always returned, if any
2272pub async fn admin_datastore_get_status(configuration: &configuration::Configuration, store: &str, verbose: Option<bool>) -> Result<models::AdminDatastoreGetStatusResponse, Error<AdminDatastoreGetStatusError>> {
2273    // add a prefix to parameters to efficiently prevent name collisions
2274    let p_path_store = store;
2275    let p_query_verbose = verbose;
2276
2277    let uri_str = format!("{}/admin/datastore/{store}/status", configuration.base_path, store=crate::apis::urlencode(p_path_store));
2278    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2279
2280    if let Some(ref param_value) = p_query_verbose {
2281        req_builder = req_builder.query(&[("verbose", &param_value.to_string())]);
2282    }
2283    if let Some(ref user_agent) = configuration.user_agent {
2284        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2285    }
2286    if let Some(ref apikey) = configuration.api_key {
2287        let key = apikey.key.clone();
2288        let value = match apikey.prefix {
2289            Some(ref prefix) => format!("{} {}", prefix, key),
2290            None => key,
2291        };
2292        req_builder = req_builder.header("Authorization", value);
2293    };
2294    if let Some(ref apikey) = configuration.api_key {
2295        let key = apikey.key.clone();
2296        let value = match apikey.prefix {
2297            Some(ref prefix) => format!("{} {}", prefix, key),
2298            None => key,
2299        };
2300        req_builder = req_builder.header("CSRFPreventionToken", value);
2301    };
2302
2303    let req = req_builder.build()?;
2304    let resp = configuration.client.execute(req).await?;
2305
2306    let status = resp.status();
2307    let content_type = resp
2308        .headers()
2309        .get("content-type")
2310        .and_then(|v| v.to_str().ok())
2311        .unwrap_or("application/octet-stream");
2312    let content_type = super::ContentType::from(content_type);
2313
2314    if !status.is_client_error() && !status.is_server_error() {
2315        let content = resp.text().await?;
2316        match content_type {
2317            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2318            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreGetStatusResponse`"))),
2319            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetStatusResponse`")))),
2320        }
2321    } else {
2322        let content = resp.text().await?;
2323        let entity: Option<AdminDatastoreGetStatusError> = serde_json::from_str(&content).ok();
2324        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2325    }
2326}
2327
2328/// Set \"notes\" for a backup group  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_MODIFY for any or DATASTORE_BACKUP and being the owner of the group
2329pub async fn admin_datastore_update_group_notes(configuration: &configuration::Configuration, store: &str, admin_datastore_update_group_notes_request: models::AdminDatastoreUpdateGroupNotesRequest) -> Result<models::AdminDatastoreUpdateGroupNotesResponse, Error<AdminDatastoreUpdateGroupNotesError>> {
2330    // add a prefix to parameters to efficiently prevent name collisions
2331    let p_path_store = store;
2332    let p_body_admin_datastore_update_group_notes_request = admin_datastore_update_group_notes_request;
2333
2334    let uri_str = format!("{}/admin/datastore/{store}/group-notes", configuration.base_path, store=crate::apis::urlencode(p_path_store));
2335    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
2336
2337    if let Some(ref user_agent) = configuration.user_agent {
2338        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2339    }
2340    if let Some(ref apikey) = configuration.api_key {
2341        let key = apikey.key.clone();
2342        let value = match apikey.prefix {
2343            Some(ref prefix) => format!("{} {}", prefix, key),
2344            None => key,
2345        };
2346        req_builder = req_builder.header("Authorization", value);
2347    };
2348    if let Some(ref apikey) = configuration.api_key {
2349        let key = apikey.key.clone();
2350        let value = match apikey.prefix {
2351            Some(ref prefix) => format!("{} {}", prefix, key),
2352            None => key,
2353        };
2354        req_builder = req_builder.header("CSRFPreventionToken", value);
2355    };
2356    req_builder = req_builder.json(&p_body_admin_datastore_update_group_notes_request);
2357
2358    let req = req_builder.build()?;
2359    let resp = configuration.client.execute(req).await?;
2360
2361    let status = resp.status();
2362    let content_type = resp
2363        .headers()
2364        .get("content-type")
2365        .and_then(|v| v.to_str().ok())
2366        .unwrap_or("application/octet-stream");
2367    let content_type = super::ContentType::from(content_type);
2368
2369    if !status.is_client_error() && !status.is_server_error() {
2370        let content = resp.text().await?;
2371        match content_type {
2372            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2373            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreUpdateGroupNotesResponse`"))),
2374            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreUpdateGroupNotesResponse`")))),
2375        }
2376    } else {
2377        let content = resp.text().await?;
2378        let entity: Option<AdminDatastoreUpdateGroupNotesError> = serde_json::from_str(&content).ok();
2379        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2380    }
2381}
2382
2383/// Set \"notes\" for a specific backup  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_MODIFY for any or DATASTORE_BACKUP and being the owner of the group
2384pub async fn admin_datastore_update_notes(configuration: &configuration::Configuration, store: &str, admin_datastore_update_notes_request: models::AdminDatastoreUpdateNotesRequest) -> Result<models::AdminDatastoreUpdateNotesResponse, Error<AdminDatastoreUpdateNotesError>> {
2385    // add a prefix to parameters to efficiently prevent name collisions
2386    let p_path_store = store;
2387    let p_body_admin_datastore_update_notes_request = admin_datastore_update_notes_request;
2388
2389    let uri_str = format!("{}/admin/datastore/{store}/notes", configuration.base_path, store=crate::apis::urlencode(p_path_store));
2390    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
2391
2392    if let Some(ref user_agent) = configuration.user_agent {
2393        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2394    }
2395    if let Some(ref apikey) = configuration.api_key {
2396        let key = apikey.key.clone();
2397        let value = match apikey.prefix {
2398            Some(ref prefix) => format!("{} {}", prefix, key),
2399            None => key,
2400        };
2401        req_builder = req_builder.header("Authorization", value);
2402    };
2403    if let Some(ref apikey) = configuration.api_key {
2404        let key = apikey.key.clone();
2405        let value = match apikey.prefix {
2406            Some(ref prefix) => format!("{} {}", prefix, key),
2407            None => key,
2408        };
2409        req_builder = req_builder.header("CSRFPreventionToken", value);
2410    };
2411    req_builder = req_builder.json(&p_body_admin_datastore_update_notes_request);
2412
2413    let req = req_builder.build()?;
2414    let resp = configuration.client.execute(req).await?;
2415
2416    let status = resp.status();
2417    let content_type = resp
2418        .headers()
2419        .get("content-type")
2420        .and_then(|v| v.to_str().ok())
2421        .unwrap_or("application/octet-stream");
2422    let content_type = super::ContentType::from(content_type);
2423
2424    if !status.is_client_error() && !status.is_server_error() {
2425        let content = resp.text().await?;
2426        match content_type {
2427            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2428            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreUpdateNotesResponse`"))),
2429            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreUpdateNotesResponse`")))),
2430        }
2431    } else {
2432        let content = resp.text().await?;
2433        let entity: Option<AdminDatastoreUpdateNotesError> = serde_json::from_str(&content).ok();
2434        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2435    }
2436}
2437
2438/// En- or disable protection for a specific backup  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_MODIFY for any or DATASTORE_BACKUP and being the owner of the group
2439pub async fn admin_datastore_update_protected(configuration: &configuration::Configuration, store: &str, admin_datastore_update_protected_request: models::AdminDatastoreUpdateProtectedRequest) -> Result<models::AdminDatastoreUpdateProtectedResponse, Error<AdminDatastoreUpdateProtectedError>> {
2440    // add a prefix to parameters to efficiently prevent name collisions
2441    let p_path_store = store;
2442    let p_body_admin_datastore_update_protected_request = admin_datastore_update_protected_request;
2443
2444    let uri_str = format!("{}/admin/datastore/{store}/protected", configuration.base_path, store=crate::apis::urlencode(p_path_store));
2445    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
2446
2447    if let Some(ref user_agent) = configuration.user_agent {
2448        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2449    }
2450    if let Some(ref apikey) = configuration.api_key {
2451        let key = apikey.key.clone();
2452        let value = match apikey.prefix {
2453            Some(ref prefix) => format!("{} {}", prefix, key),
2454            None => key,
2455        };
2456        req_builder = req_builder.header("Authorization", value);
2457    };
2458    if let Some(ref apikey) = configuration.api_key {
2459        let key = apikey.key.clone();
2460        let value = match apikey.prefix {
2461            Some(ref prefix) => format!("{} {}", prefix, key),
2462            None => key,
2463        };
2464        req_builder = req_builder.header("CSRFPreventionToken", value);
2465    };
2466    req_builder = req_builder.json(&p_body_admin_datastore_update_protected_request);
2467
2468    let req = req_builder.build()?;
2469    let resp = configuration.client.execute(req).await?;
2470
2471    let status = resp.status();
2472    let content_type = resp
2473        .headers()
2474        .get("content-type")
2475        .and_then(|v| v.to_str().ok())
2476        .unwrap_or("application/octet-stream");
2477    let content_type = super::ContentType::from(content_type);
2478
2479    if !status.is_client_error() && !status.is_server_error() {
2480        let content = resp.text().await?;
2481        match content_type {
2482            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2483            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreUpdateProtectedResponse`"))),
2484            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreUpdateProtectedResponse`")))),
2485        }
2486    } else {
2487        let content = resp.text().await?;
2488        let entity: Option<AdminDatastoreUpdateProtectedError> = serde_json::from_str(&content).ok();
2489        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2490    }
2491}
2492
2493/// Refresh datastore contents from S3 to local cache store.
2494pub async fn admin_datastore_update_s3_refresh(configuration: &configuration::Configuration, store: &str) -> Result<models::AdminDatastoreUpdateS3RefreshResponse, Error<AdminDatastoreUpdateS3RefreshError>> {
2495    // add a prefix to parameters to efficiently prevent name collisions
2496    let p_path_store = store;
2497
2498    let uri_str = format!("{}/admin/datastore/{store}/s3-refresh", configuration.base_path, store=crate::apis::urlencode(p_path_store));
2499    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
2500
2501    if let Some(ref user_agent) = configuration.user_agent {
2502        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2503    }
2504    if let Some(ref apikey) = configuration.api_key {
2505        let key = apikey.key.clone();
2506        let value = match apikey.prefix {
2507            Some(ref prefix) => format!("{} {}", prefix, key),
2508            None => key,
2509        };
2510        req_builder = req_builder.header("Authorization", value);
2511    };
2512    if let Some(ref apikey) = configuration.api_key {
2513        let key = apikey.key.clone();
2514        let value = match apikey.prefix {
2515            Some(ref prefix) => format!("{} {}", prefix, key),
2516            None => key,
2517        };
2518        req_builder = req_builder.header("CSRFPreventionToken", value);
2519    };
2520
2521    let req = req_builder.build()?;
2522    let resp = configuration.client.execute(req).await?;
2523
2524    let status = resp.status();
2525    let content_type = resp
2526        .headers()
2527        .get("content-type")
2528        .and_then(|v| v.to_str().ok())
2529        .unwrap_or("application/octet-stream");
2530    let content_type = super::ContentType::from(content_type);
2531
2532    if !status.is_client_error() && !status.is_server_error() {
2533        let content = resp.text().await?;
2534        match content_type {
2535            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2536            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AdminDatastoreUpdateS3RefreshResponse`"))),
2537            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreUpdateS3RefreshResponse`")))),
2538        }
2539    } else {
2540        let content = resp.text().await?;
2541        let entity: Option<AdminDatastoreUpdateS3RefreshError> = serde_json::from_str(&content).ok();
2542        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2543    }
2544}
2545
clientapi_pbs/apis/admin_datastore_api.rs

clientapi_pbs/apis/
admin_datastore_api.rs
