wings_api/
client.rs

1// This file is auto-generated from OpenAPI spec. Do not edit manually.
2use super::*;
3use futures_util::TryStreamExt;
4use http_client::{CLIENT, USER_AGENT};
5use reqwest::{Method, StatusCode};
6use serde::de::DeserializeOwned;
7use std::{
8    pin::Pin,
9    task::{Context, Poll},
10};
11use tokio::io::AsyncRead;
12use tokio_tungstenite::tungstenite::{Error, client::IntoClientRequest, http::HeaderValue};
13
14#[derive(Debug)]
15pub enum ApiHttpError {
16    Http(StatusCode, super::ApiError),
17    Reqwest(reqwest::Error),
18    WebSocket(tokio_tungstenite::tungstenite::Error),
19    MsgpackEncode(rmp_serde::encode::Error),
20    MsgpackDecode(rmp_serde::decode::Error),
21}
22
23impl From<ApiHttpError> for anyhow::Error {
24    fn from(value: ApiHttpError) -> Self {
25        match value {
26            ApiHttpError::Http(status, err) => {
27                anyhow::anyhow!("wings api status code {status}: {}", err.error)
28            }
29            ApiHttpError::Reqwest(err) => anyhow::anyhow!(err),
30            ApiHttpError::WebSocket(err) => anyhow::anyhow!(err),
31            ApiHttpError::MsgpackEncode(err) => anyhow::anyhow!(err),
32            ApiHttpError::MsgpackDecode(err) => anyhow::anyhow!(err),
33        }
34    }
35}
36
37pub struct AsyncResponseReader(Box<dyn AsyncRead + Send + Unpin>);
38
39impl AsyncRead for AsyncResponseReader {
40    fn poll_read(
41        mut self: Pin<&mut Self>,
42        cx: &mut Context<'_>,
43        buf: &mut tokio::io::ReadBuf<'_>,
44    ) -> Poll<std::io::Result<()>> {
45        Pin::new(&mut self.0).poll_read(cx, buf)
46    }
47}
48
49impl<'de> Deserialize<'de> for AsyncResponseReader {
50    fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
51    where
52        D: serde::Deserializer<'de>,
53    {
54        Ok(Self(Box::new(tokio::io::empty())))
55    }
56}
57
58pub struct AsyncRequestReader(Box<dyn AsyncRead + Send + Unpin>);
59
60impl AsyncRequestReader {
61    #[inline]
62    pub fn new(reader: impl AsyncRead + Send + Unpin + 'static) -> Self {
63        Self(Box::new(reader))
64    }
65}
66
67impl AsyncRead for AsyncRequestReader {
68    fn poll_read(
69        mut self: Pin<&mut Self>,
70        cx: &mut Context<'_>,
71        buf: &mut tokio::io::ReadBuf<'_>,
72    ) -> Poll<std::io::Result<()>> {
73        Pin::new(&mut self.0).poll_read(cx, buf)
74    }
75}
76
77async fn request_impl<T: DeserializeOwned + 'static>(
78    client: &WingsClient,
79    method: Method,
80    endpoint: impl AsRef<str>,
81    body: Option<&impl Serialize>,
82    body_reader: Option<AsyncRequestReader>,
83) -> Result<T, ApiHttpError> {
84    let url = format!(
85        "{}{}",
86        client.base_url.trim_end_matches('/'),
87        endpoint.as_ref()
88    );
89    let mut request = CLIENT.request(method, &url);
90    request = request.header("Accept", "application/msgpack");
91
92    if !client.token.is_empty() {
93        request = request.header("Authorization", format!("Bearer {}", client.token));
94    }
95
96    if let Some(body) = body {
97        request = request.header("Content-Type", "application/msgpack");
98
99        let mut bytes = Vec::new();
100        let mut se = rmp_serde::Serializer::new(&mut bytes)
101            .with_struct_map()
102            .with_human_readable();
103        if let Err(err) = body.serialize(&mut se) {
104            return Err(ApiHttpError::MsgpackEncode(err));
105        }
106        request = request.body(bytes);
107    } else if let Some(body_reader) = body_reader {
108        request = request.body(reqwest::Body::wrap_stream(
109            tokio_util::io::ReaderStream::new(body_reader),
110        ));
111    }
112
113    match request.send().await {
114        Ok(response) => {
115            if response.status().is_success() {
116                if std::any::type_name::<T>() == std::any::type_name::<AsyncResponseReader>() {
117                    let stream = response.bytes_stream().map_err(|err| {
118                        std::io::Error::other(format!("failed to read multipart field: {err}"))
119                    });
120                    let stream_reader = tokio_util::io::StreamReader::new(stream);
121
122                    return Ok(*(Box::new(AsyncResponseReader(Box::new(stream_reader)))
123                        as Box<dyn std::any::Any>)
124                        .downcast::<T>()
125                        .unwrap());
126                }
127
128                match response.bytes().await {
129                    Ok(data) => {
130                        let mut de =
131                            rmp_serde::Deserializer::new(data.as_ref()).with_human_readable();
132                        match T::deserialize(&mut de) {
133                            Ok(data) => Ok(data),
134                            Err(err) => Err(ApiHttpError::MsgpackDecode(err)),
135                        }
136                    }
137                    Err(err) => Err(ApiHttpError::Reqwest(err)),
138                }
139            } else {
140                Err(ApiHttpError::Http(
141                    response.status(),
142                    match response.bytes().await {
143                        Ok(data) => {
144                            let mut de =
145                                rmp_serde::Deserializer::new(data.as_ref()).with_human_readable();
146                            match super::ApiError::deserialize(&mut de) {
147                                Ok(data) => data,
148                                Err(err) => super::ApiError {
149                                    error: err.to_string().into(),
150                                },
151                            }
152                        }
153                        Err(err) => super::ApiError {
154                            error: err.to_string().into(),
155                        },
156                    },
157                ))
158            }
159        }
160        Err(err) => Err(ApiHttpError::Reqwest(err)),
161    }
162}
163
164pub struct WingsClient {
165    base_url: String,
166    token: String,
167    ignored: Vec<compact_str::CompactString>,
168    destination_ignored: Vec<compact_str::CompactString>,
169}
170
171impl WingsClient {
172    #[inline]
173    pub fn new(base_url: String, token: String) -> Self {
174        Self {
175            base_url,
176            token,
177            ignored: Vec::new(),
178            destination_ignored: Vec::new(),
179        }
180    }
181
182    /// Paths the node has to treat as invisible for every request made through this client,
183    /// mirroring the ignore rules of the subuser the request is made on behalf of. Empty by
184    /// default, which is what an unrestricted caller wants.
185    #[inline]
186    pub fn ignoring(mut self, ignored: Vec<compact_str::CompactString>) -> Self {
187        self.ignored = ignored;
188        self
189    }
190
191    /// [WingsClient::ignoring] for the destination server of a cross-server transfer.
192    #[inline]
193    pub fn ignoring_destination(
194        mut self,
195        destination_ignored: Vec<compact_str::CompactString>,
196    ) -> Self {
197        self.destination_ignored = destination_ignored;
198        self
199    }
200
201    pub fn request_raw(
202        &self,
203        method: Method,
204        endpoint: impl AsRef<str>,
205    ) -> reqwest::RequestBuilder {
206        let url = format!(
207            "{}/{}",
208            self.base_url.trim_end_matches('/'),
209            endpoint.as_ref().trim_start_matches('/')
210        );
211        let mut request = CLIENT.request(method, &url);
212
213        if !self.token.is_empty() {
214            request = request.header("Authorization", format!("Bearer {}", self.token));
215        }
216
217        request
218    }
219
220    pub async fn open_websocket(
221        &self,
222        endpoint: impl AsRef<str>,
223        headers: reqwest::header::HeaderMap,
224    ) -> Result<
225        tokio_tungstenite::WebSocketStream<
226            tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,
227        >,
228        ApiHttpError,
229    > {
230        let url = format!(
231            "{}{}",
232            self.base_url.trim_end_matches('/'),
233            endpoint.as_ref()
234        );
235        let url = if let Some(rest) = url.strip_prefix("https://") {
236            format!("wss://{rest}")
237        } else if let Some(rest) = url.strip_prefix("http://") {
238            format!("ws://{rest}")
239        } else {
240            url
241        };
242
243        let mut request = url.into_client_request().map_err(ApiHttpError::WebSocket)?;
244
245        request
246            .headers_mut()
247            .insert("User-Agent", HeaderValue::from_static(USER_AGENT));
248
249        if !self.token.is_empty() {
250            let value = HeaderValue::from_str(&format!("Bearer {}", self.token))
251                .map_err(|err| ApiHttpError::WebSocket(Error::HttpFormat(err.into())))?;
252            request.headers_mut().insert("Authorization", value);
253        }
254
255        for (header, value) in headers {
256            let Some(header) = header else {
257                continue;
258            };
259            request.headers_mut().insert(header, value);
260        }
261
262        let (stream, _) = tokio_tungstenite::connect_async(request)
263            .await
264            .map_err(ApiHttpError::WebSocket)?;
265
266        Ok(stream)
267    }
268
269    pub async fn delete_backups_backup(
270        &self,
271        backup: uuid::Uuid,
272        data: &super::backups_backup::delete::RequestBody,
273    ) -> Result<super::backups_backup::delete::Response, ApiHttpError> {
274        request_impl(
275            self,
276            Method::DELETE,
277            format!("/api/backups/{backup}"),
278            Some(data),
279            None,
280        )
281        .await
282    }
283
284    pub async fn post_backups_backup_export(
285        &self,
286        backup: uuid::Uuid,
287        data: &super::backups_backup_export::post::RequestBody,
288    ) -> Result<super::backups_backup_export::post::Response, ApiHttpError> {
289        request_impl(
290            self,
291            Method::POST,
292            format!("/api/backups/{backup}/export"),
293            Some(&BackupsBackupExportPostBody {
294                inner: data,
295                ignored: &self.ignored,
296            }),
297            None,
298        )
299        .await
300    }
301
302    pub async fn get_backups_backup_query(
303        &self,
304        backup: uuid::Uuid,
305        query: &super::backups_backup_query::get::Query,
306    ) -> Result<super::backups_backup_query::get::Response, ApiHttpError> {
307        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
308        if let Some(value) = query.adapter {
309            query_parts.push(format!("adapter={}", value).into());
310        }
311        let query = if query_parts.is_empty() {
312            String::new()
313        } else {
314            format!("?{}", query_parts.join("&"))
315        };
316        request_impl(
317            self,
318            Method::GET,
319            format!("/api/backups/{backup}/query{query}"),
320            None::<&()>,
321            None,
322        )
323        .await
324    }
325
326    pub async fn post_deauthorize_user(
327        &self,
328        data: &super::deauthorize_user::post::RequestBody,
329    ) -> Result<super::deauthorize_user::post::Response, ApiHttpError> {
330        request_impl(
331            self,
332            Method::POST,
333            "/api/deauthorize-user",
334            Some(data),
335            None,
336        )
337        .await
338    }
339
340    pub async fn post_permissions_invalidate(
341        &self,
342        data: &super::permissions_invalidate::post::RequestBody,
343    ) -> Result<super::permissions_invalidate::post::Response, ApiHttpError> {
344        request_impl(
345            self,
346            Method::POST,
347            "/api/permissions/invalidate",
348            Some(data),
349            None,
350        )
351        .await
352    }
353
354    pub async fn get_ports_used(
355        &self,
356        query: &super::ports_used::get::Query,
357    ) -> Result<super::ports_used::get::Response, ApiHttpError> {
358        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
359        if let Some(value) = &query.ip {
360            for value in value {
361                query_parts.push(format!("ip={}", urlencoding::encode(value)).into());
362            }
363        }
364        let query = if query_parts.is_empty() {
365            String::new()
366        } else {
367            format!("?{}", query_parts.join("&"))
368        };
369        request_impl(
370            self,
371            Method::GET,
372            format!("/api/ports/used{query}"),
373            None::<&()>,
374            None,
375        )
376        .await
377    }
378
379    pub async fn get_servers(&self) -> Result<super::servers::get::Response, ApiHttpError> {
380        request_impl(self, Method::GET, "/api/servers", None::<&()>, None).await
381    }
382
383    pub async fn post_servers(
384        &self,
385        data: &super::servers::post::RequestBody,
386    ) -> Result<super::servers::post::Response, ApiHttpError> {
387        request_impl(self, Method::POST, "/api/servers", Some(data), None).await
388    }
389
390    pub async fn post_servers_power(
391        &self,
392        data: &super::servers_power::post::RequestBody,
393    ) -> Result<super::servers_power::post::Response, ApiHttpError> {
394        request_impl(self, Method::POST, "/api/servers/power", Some(data), None).await
395    }
396
397    pub async fn get_servers_utilization(
398        &self,
399    ) -> Result<super::servers_utilization::get::Response, ApiHttpError> {
400        request_impl(
401            self,
402            Method::GET,
403            "/api/servers/utilization",
404            None::<&()>,
405            None,
406        )
407        .await
408    }
409
410    pub async fn get_servers_server(
411        &self,
412        server: uuid::Uuid,
413    ) -> Result<super::servers_server::get::Response, ApiHttpError> {
414        request_impl(
415            self,
416            Method::GET,
417            format!("/api/servers/{server}"),
418            None::<&()>,
419            None,
420        )
421        .await
422    }
423
424    pub async fn delete_servers_server(
425        &self,
426        server: uuid::Uuid,
427    ) -> Result<super::servers_server::delete::Response, ApiHttpError> {
428        request_impl(
429            self,
430            Method::DELETE,
431            format!("/api/servers/{server}"),
432            None::<&()>,
433            None,
434        )
435        .await
436    }
437
438    pub async fn post_servers_server_backup(
439        &self,
440        server: uuid::Uuid,
441        data: &super::servers_server_backup::post::RequestBody,
442    ) -> Result<super::servers_server_backup::post::Response, ApiHttpError> {
443        request_impl(
444            self,
445            Method::POST,
446            format!("/api/servers/{server}/backup"),
447            Some(data),
448            None,
449        )
450        .await
451    }
452
453    pub async fn delete_servers_server_backup_backup(
454        &self,
455        server: uuid::Uuid,
456        backup: uuid::Uuid,
457    ) -> Result<super::servers_server_backup_backup::delete::Response, ApiHttpError> {
458        request_impl(
459            self,
460            Method::DELETE,
461            format!("/api/servers/{server}/backup/{backup}"),
462            None::<&()>,
463            None,
464        )
465        .await
466    }
467
468    pub async fn post_servers_server_backup_backup_restore(
469        &self,
470        server: uuid::Uuid,
471        backup: uuid::Uuid,
472        data: &super::servers_server_backup_backup_restore::post::RequestBody,
473    ) -> Result<super::servers_server_backup_backup_restore::post::Response, ApiHttpError> {
474        request_impl(
475            self,
476            Method::POST,
477            format!("/api/servers/{server}/backup/{backup}/restore"),
478            Some(data),
479            None,
480        )
481        .await
482    }
483
484    pub async fn post_servers_server_commands(
485        &self,
486        server: uuid::Uuid,
487        data: &super::servers_server_commands::post::RequestBody,
488    ) -> Result<super::servers_server_commands::post::Response, ApiHttpError> {
489        request_impl(
490            self,
491            Method::POST,
492            format!("/api/servers/{server}/commands"),
493            Some(data),
494            None,
495        )
496        .await
497    }
498
499    pub async fn post_servers_server_database_backup(
500        &self,
501        server: uuid::Uuid,
502        data: &super::servers_server_database_backup::post::RequestBody,
503    ) -> Result<super::servers_server_database_backup::post::Response, ApiHttpError> {
504        request_impl(
505            self,
506            Method::POST,
507            format!("/api/servers/{server}/database-backup"),
508            Some(data),
509            None,
510        )
511        .await
512    }
513
514    pub async fn post_servers_server_database_backup_backup_restore(
515        &self,
516        server: uuid::Uuid,
517        backup: uuid::Uuid,
518        data: &super::servers_server_database_backup_backup_restore::post::RequestBody,
519    ) -> Result<super::servers_server_database_backup_backup_restore::post::Response, ApiHttpError>
520    {
521        request_impl(
522            self,
523            Method::POST,
524            format!("/api/servers/{server}/database-backup/{backup}/restore"),
525            Some(data),
526            None,
527        )
528        .await
529    }
530
531    pub async fn post_servers_server_files_chmod(
532        &self,
533        server: uuid::Uuid,
534        data: &super::servers_server_files_chmod::post::RequestBody,
535    ) -> Result<super::servers_server_files_chmod::post::Response, ApiHttpError> {
536        request_impl(
537            self,
538            Method::POST,
539            format!("/api/servers/{server}/files/chmod"),
540            Some(&ServersServerFilesChmodPostBody {
541                inner: data,
542                ignored: &self.ignored,
543            }),
544            None,
545        )
546        .await
547    }
548
549    pub async fn post_servers_server_files_compress(
550        &self,
551        server: uuid::Uuid,
552        data: &super::servers_server_files_compress::post::RequestBody,
553    ) -> Result<super::servers_server_files_compress::post::Response, ApiHttpError> {
554        request_impl(
555            self,
556            Method::POST,
557            format!("/api/servers/{server}/files/compress"),
558            Some(&ServersServerFilesCompressPostBody {
559                inner: data,
560                ignored: &self.ignored,
561            }),
562            None,
563        )
564        .await
565    }
566
567    pub async fn get_servers_server_files_contents(
568        &self,
569        server: uuid::Uuid,
570        query: &super::servers_server_files_contents::get::Query,
571    ) -> Result<super::servers_server_files_contents::get::Response, ApiHttpError> {
572        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
573        if let Some(value) = &query.file {
574            query_parts.push(format!("file={}", urlencoding::encode(value)).into());
575        }
576        if let Some(value) = query.download {
577            query_parts.push(format!("download={}", value).into());
578        }
579        if let Some(value) = query.max_size {
580            query_parts.push(format!("max_size={}", value).into());
581        }
582        if let Some(value) = &query.ignored {
583            for value in value {
584                query_parts.push(format!("ignored={}", urlencoding::encode(value)).into());
585            }
586        }
587        let query = if query_parts.is_empty() {
588            String::new()
589        } else {
590            format!("?{}", query_parts.join("&"))
591        };
592        request_impl(
593            self,
594            Method::GET,
595            format!("/api/servers/{server}/files/contents{query}"),
596            None::<&()>,
597            None,
598        )
599        .await
600    }
601
602    pub async fn post_servers_server_files_copy(
603        &self,
604        server: uuid::Uuid,
605        data: &super::servers_server_files_copy::post::RequestBody,
606    ) -> Result<super::servers_server_files_copy::post::Response, ApiHttpError> {
607        request_impl(
608            self,
609            Method::POST,
610            format!("/api/servers/{server}/files/copy"),
611            Some(&ServersServerFilesCopyPostBody {
612                inner: data,
613                ignored: &self.ignored,
614            }),
615            None,
616        )
617        .await
618    }
619
620    pub async fn post_servers_server_files_copy_many(
621        &self,
622        server: uuid::Uuid,
623        data: &super::servers_server_files_copy_many::post::RequestBody,
624    ) -> Result<super::servers_server_files_copy_many::post::Response, ApiHttpError> {
625        request_impl(
626            self,
627            Method::POST,
628            format!("/api/servers/{server}/files/copy-many"),
629            Some(&ServersServerFilesCopyManyPostBody {
630                inner: data,
631                ignored: &self.ignored,
632            }),
633            None,
634        )
635        .await
636    }
637
638    pub async fn post_servers_server_files_copy_remote(
639        &self,
640        server: uuid::Uuid,
641        data: &super::servers_server_files_copy_remote::post::RequestBody,
642    ) -> Result<super::servers_server_files_copy_remote::post::Response, ApiHttpError> {
643        self.post_servers_server_files_copy_remote_with(server, data, &Default::default())
644            .await
645    }
646
647    pub async fn post_servers_server_files_copy_remote_with(
648        &self,
649        server: uuid::Uuid,
650        data: &super::servers_server_files_copy_remote::post::RequestBody,
651        extra: &super::servers_server_files_copy_remote::post::Extra,
652    ) -> Result<super::servers_server_files_copy_remote::post::Response, ApiHttpError> {
653        request_impl(
654            self,
655            Method::POST,
656            format!("/api/servers/{server}/files/copy-remote"),
657            Some(&ServersServerFilesCopyRemotePostBody {
658                inner: data,
659                ignored: &self.ignored,
660                destination_ignored: &self.destination_ignored,
661                overwrite: &extra.overwrite,
662            }),
663            None,
664        )
665        .await
666    }
667
668    pub async fn post_servers_server_files_create_directory(
669        &self,
670        server: uuid::Uuid,
671        data: &super::servers_server_files_create_directory::post::RequestBody,
672    ) -> Result<super::servers_server_files_create_directory::post::Response, ApiHttpError> {
673        request_impl(
674            self,
675            Method::POST,
676            format!("/api/servers/{server}/files/create-directory"),
677            Some(&ServersServerFilesCreateDirectoryPostBody {
678                inner: data,
679                ignored: &self.ignored,
680            }),
681            None,
682        )
683        .await
684    }
685
686    pub async fn post_servers_server_files_create_symlink(
687        &self,
688        server: uuid::Uuid,
689        data: &super::servers_server_files_create_symlink::post::RequestBody,
690    ) -> Result<super::servers_server_files_create_symlink::post::Response, ApiHttpError> {
691        request_impl(
692            self,
693            Method::POST,
694            format!("/api/servers/{server}/files/create-symlink"),
695            Some(&ServersServerFilesCreateSymlinkPostBody {
696                inner: data,
697                ignored: &self.ignored,
698            }),
699            None,
700        )
701        .await
702    }
703
704    pub async fn post_servers_server_files_decompress(
705        &self,
706        server: uuid::Uuid,
707        data: &super::servers_server_files_decompress::post::RequestBody,
708    ) -> Result<super::servers_server_files_decompress::post::Response, ApiHttpError> {
709        request_impl(
710            self,
711            Method::POST,
712            format!("/api/servers/{server}/files/decompress"),
713            Some(&ServersServerFilesDecompressPostBody {
714                inner: data,
715                ignored: &self.ignored,
716            }),
717            None,
718        )
719        .await
720    }
721
722    pub async fn post_servers_server_files_delete(
723        &self,
724        server: uuid::Uuid,
725        data: &super::servers_server_files_delete::post::RequestBody,
726    ) -> Result<super::servers_server_files_delete::post::Response, ApiHttpError> {
727        request_impl(
728            self,
729            Method::POST,
730            format!("/api/servers/{server}/files/delete"),
731            Some(&ServersServerFilesDeletePostBody {
732                inner: data,
733                ignored: &self.ignored,
734            }),
735            None,
736        )
737        .await
738    }
739
740    pub async fn get_servers_server_files_directory_sizes(
741        &self,
742        server: uuid::Uuid,
743        query: &super::servers_server_files_directory_sizes::get::Query,
744    ) -> Result<super::servers_server_files_directory_sizes::get::Response, ApiHttpError> {
745        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
746        if let Some(value) = &query.directory {
747            query_parts.push(format!("directory={}", urlencoding::encode(value)).into());
748        }
749        if let Some(value) = query.depth {
750            query_parts.push(format!("depth={}", value).into());
751        }
752        if let Some(value) = &query.ignored {
753            for value in value {
754                query_parts.push(format!("ignored={}", urlencoding::encode(value)).into());
755            }
756        }
757        let query = if query_parts.is_empty() {
758            String::new()
759        } else {
760            format!("?{}", query_parts.join("&"))
761        };
762        request_impl(
763            self,
764            Method::GET,
765            format!("/api/servers/{server}/files/directory-sizes{query}"),
766            None::<&()>,
767            None,
768        )
769        .await
770    }
771
772    pub async fn get_servers_server_files_fingerprints(
773        &self,
774        server: uuid::Uuid,
775        query: &super::servers_server_files_fingerprints::get::Query,
776    ) -> Result<super::servers_server_files_fingerprints::get::Response, ApiHttpError> {
777        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
778        if let Some(value) = query.algorithm {
779            query_parts.push(format!("algorithm={}", value).into());
780        }
781        if let Some(value) = &query.files {
782            for value in value {
783                query_parts.push(format!("files={}", urlencoding::encode(value)).into());
784            }
785        }
786        if let Some(value) = &query.ignored {
787            for value in value {
788                query_parts.push(format!("ignored={}", urlencoding::encode(value)).into());
789            }
790        }
791        let query = if query_parts.is_empty() {
792            String::new()
793        } else {
794            format!("?{}", query_parts.join("&"))
795        };
796        request_impl(
797            self,
798            Method::GET,
799            format!("/api/servers/{server}/files/fingerprints{query}"),
800            None::<&()>,
801            None,
802        )
803        .await
804    }
805
806    pub async fn post_servers_server_files_ignore_matches(
807        &self,
808        server: uuid::Uuid,
809        data: &super::servers_server_files_ignore_matches::post::RequestBody,
810    ) -> Result<super::servers_server_files_ignore_matches::post::Response, ApiHttpError> {
811        request_impl(
812            self,
813            Method::POST,
814            format!("/api/servers/{server}/files/ignore-matches"),
815            Some(&ServersServerFilesIgnoreMatchesPostBody {
816                inner: data,
817                ignored: &self.ignored,
818            }),
819            None,
820        )
821        .await
822    }
823
824    pub async fn get_servers_server_files_largest_directories(
825        &self,
826        server: uuid::Uuid,
827        query: &super::servers_server_files_largest_directories::get::Query,
828    ) -> Result<super::servers_server_files_largest_directories::get::Response, ApiHttpError> {
829        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
830        if let Some(value) = &query.directory {
831            query_parts.push(format!("directory={}", urlencoding::encode(value)).into());
832        }
833        if let Some(value) = &query.ignored {
834            for value in value {
835                query_parts.push(format!("ignored={}", urlencoding::encode(value)).into());
836            }
837        }
838        let query = if query_parts.is_empty() {
839            String::new()
840        } else {
841            format!("?{}", query_parts.join("&"))
842        };
843        request_impl(
844            self,
845            Method::GET,
846            format!("/api/servers/{server}/files/largest-directories{query}"),
847            None::<&()>,
848            None,
849        )
850        .await
851    }
852
853    pub async fn get_servers_server_files_lines(
854        &self,
855        server: uuid::Uuid,
856        query: &super::servers_server_files_lines::get::Query,
857    ) -> Result<super::servers_server_files_lines::get::Response, ApiHttpError> {
858        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
859        if let Some(value) = &query.file {
860            query_parts.push(format!("file={}", urlencoding::encode(value)).into());
861        }
862        if let Some(value) = query.start_line {
863            query_parts.push(format!("start_line={}", value).into());
864        }
865        if let Some(value) = query.end_line {
866            query_parts.push(format!("end_line={}", value).into());
867        }
868        if let Some(value) = query.max_size {
869            query_parts.push(format!("max_size={}", value).into());
870        }
871        if let Some(value) = &query.ignored {
872            for value in value {
873                query_parts.push(format!("ignored={}", urlencoding::encode(value)).into());
874            }
875        }
876        let query = if query_parts.is_empty() {
877            String::new()
878        } else {
879            format!("?{}", query_parts.join("&"))
880        };
881        request_impl(
882            self,
883            Method::GET,
884            format!("/api/servers/{server}/files/lines{query}"),
885            None::<&()>,
886            None,
887        )
888        .await
889    }
890
891    pub async fn get_servers_server_files_list(
892        &self,
893        server: uuid::Uuid,
894        query: &super::servers_server_files_list::get::Query,
895    ) -> Result<super::servers_server_files_list::get::Response, ApiHttpError> {
896        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
897        if let Some(value) = &query.directory {
898            query_parts.push(format!("directory={}", urlencoding::encode(value)).into());
899        }
900        if let Some(value) = &query.ignored {
901            for value in value {
902                query_parts.push(format!("ignored={}", urlencoding::encode(value)).into());
903            }
904        }
905        if let Some(value) = query.per_page {
906            query_parts.push(format!("per_page={}", value).into());
907        }
908        if let Some(value) = query.page {
909            query_parts.push(format!("page={}", value).into());
910        }
911        if let Some(value) = query.sort {
912            query_parts.push(format!("sort={}", value).into());
913        }
914        let query = if query_parts.is_empty() {
915            String::new()
916        } else {
917            format!("?{}", query_parts.join("&"))
918        };
919        request_impl(
920            self,
921            Method::GET,
922            format!("/api/servers/{server}/files/list{query}"),
923            None::<&()>,
924            None,
925        )
926        .await
927    }
928
929    pub async fn get_servers_server_files_list_directory(
930        &self,
931        server: uuid::Uuid,
932        query: &super::servers_server_files_list_directory::get::Query,
933    ) -> Result<super::servers_server_files_list_directory::get::Response, ApiHttpError> {
934        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
935        if let Some(value) = &query.directory {
936            query_parts.push(format!("directory={}", urlencoding::encode(value)).into());
937        }
938        let query = if query_parts.is_empty() {
939            String::new()
940        } else {
941            format!("?{}", query_parts.join("&"))
942        };
943        request_impl(
944            self,
945            Method::GET,
946            format!("/api/servers/{server}/files/list-directory{query}"),
947            None::<&()>,
948            None,
949        )
950        .await
951    }
952
953    pub async fn get_servers_server_files_operations(
954        &self,
955        server: uuid::Uuid,
956    ) -> Result<super::servers_server_files_operations::get::Response, ApiHttpError> {
957        request_impl(
958            self,
959            Method::GET,
960            format!("/api/servers/{server}/files/operations"),
961            None::<&()>,
962            None,
963        )
964        .await
965    }
966
967    pub async fn delete_servers_server_files_operations_operation(
968        &self,
969        server: uuid::Uuid,
970        operation: uuid::Uuid,
971    ) -> Result<super::servers_server_files_operations_operation::delete::Response, ApiHttpError>
972    {
973        request_impl(
974            self,
975            Method::DELETE,
976            format!("/api/servers/{server}/files/operations/{operation}"),
977            None::<&()>,
978            None,
979        )
980        .await
981    }
982
983    pub async fn get_servers_server_files_pull(
984        &self,
985        server: uuid::Uuid,
986    ) -> Result<super::servers_server_files_pull::get::Response, ApiHttpError> {
987        request_impl(
988            self,
989            Method::GET,
990            format!("/api/servers/{server}/files/pull"),
991            None::<&()>,
992            None,
993        )
994        .await
995    }
996
997    pub async fn post_servers_server_files_pull(
998        &self,
999        server: uuid::Uuid,
1000        data: &super::servers_server_files_pull::post::RequestBody,
1001    ) -> Result<super::servers_server_files_pull::post::Response, ApiHttpError> {
1002        request_impl(
1003            self,
1004            Method::POST,
1005            format!("/api/servers/{server}/files/pull"),
1006            Some(&ServersServerFilesPullPostBody {
1007                inner: data,
1008                ignored: &self.ignored,
1009            }),
1010            None,
1011        )
1012        .await
1013    }
1014
1015    pub async fn post_servers_server_files_pull_query(
1016        &self,
1017        server: uuid::Uuid,
1018        data: &super::servers_server_files_pull_query::post::RequestBody,
1019    ) -> Result<super::servers_server_files_pull_query::post::Response, ApiHttpError> {
1020        request_impl(
1021            self,
1022            Method::POST,
1023            format!("/api/servers/{server}/files/pull/query"),
1024            Some(data),
1025            None,
1026        )
1027        .await
1028    }
1029
1030    pub async fn delete_servers_server_files_pull_pull(
1031        &self,
1032        server: uuid::Uuid,
1033        pull: uuid::Uuid,
1034    ) -> Result<super::servers_server_files_pull_pull::delete::Response, ApiHttpError> {
1035        request_impl(
1036            self,
1037            Method::DELETE,
1038            format!("/api/servers/{server}/files/pull/{pull}"),
1039            None::<&()>,
1040            None,
1041        )
1042        .await
1043    }
1044
1045    pub async fn put_servers_server_files_rename(
1046        &self,
1047        server: uuid::Uuid,
1048        data: &super::servers_server_files_rename::put::RequestBody,
1049    ) -> Result<super::servers_server_files_rename::put::Response, ApiHttpError> {
1050        self.put_servers_server_files_rename_with(server, data, &Default::default())
1051            .await
1052    }
1053
1054    pub async fn put_servers_server_files_rename_with(
1055        &self,
1056        server: uuid::Uuid,
1057        data: &super::servers_server_files_rename::put::RequestBody,
1058        extra: &super::servers_server_files_rename::put::Extra,
1059    ) -> Result<super::servers_server_files_rename::put::Response, ApiHttpError> {
1060        request_impl(
1061            self,
1062            Method::PUT,
1063            format!("/api/servers/{server}/files/rename"),
1064            Some(&ServersServerFilesRenamePutBody {
1065                inner: data,
1066                ignored: &self.ignored,
1067                create_directories: &extra.create_directories,
1068            }),
1069            None,
1070        )
1071        .await
1072    }
1073
1074    pub async fn get_servers_server_files_revisions(
1075        &self,
1076        server: uuid::Uuid,
1077        query: &super::servers_server_files_revisions::get::Query,
1078    ) -> Result<super::servers_server_files_revisions::get::Response, ApiHttpError> {
1079        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
1080        if let Some(value) = &query.file {
1081            query_parts.push(format!("file={}", urlencoding::encode(value)).into());
1082        }
1083        if let Some(value) = &query.ignored {
1084            for value in value {
1085                query_parts.push(format!("ignored={}", urlencoding::encode(value)).into());
1086            }
1087        }
1088        let query = if query_parts.is_empty() {
1089            String::new()
1090        } else {
1091            format!("?{}", query_parts.join("&"))
1092        };
1093        request_impl(
1094            self,
1095            Method::GET,
1096            format!("/api/servers/{server}/files/revisions{query}"),
1097            None::<&()>,
1098            None,
1099        )
1100        .await
1101    }
1102
1103    pub async fn get_servers_server_files_revisions_revision(
1104        &self,
1105        server: uuid::Uuid,
1106        revision: i64,
1107        query: &super::servers_server_files_revisions_revision::get::Query,
1108    ) -> Result<super::servers_server_files_revisions_revision::get::Response, ApiHttpError> {
1109        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
1110        if let Some(value) = &query.file {
1111            query_parts.push(format!("file={}", urlencoding::encode(value)).into());
1112        }
1113        if let Some(value) = &query.ignored {
1114            for value in value {
1115                query_parts.push(format!("ignored={}", urlencoding::encode(value)).into());
1116            }
1117        }
1118        let query = if query_parts.is_empty() {
1119            String::new()
1120        } else {
1121            format!("?{}", query_parts.join("&"))
1122        };
1123        request_impl(
1124            self,
1125            Method::GET,
1126            format!("/api/servers/{server}/files/revisions/{revision}{query}"),
1127            None::<&()>,
1128            None,
1129        )
1130        .await
1131    }
1132
1133    pub async fn post_servers_server_files_search(
1134        &self,
1135        server: uuid::Uuid,
1136        data: &super::servers_server_files_search::post::RequestBody,
1137    ) -> Result<super::servers_server_files_search::post::Response, ApiHttpError> {
1138        self.post_servers_server_files_search_with(server, data, &Default::default())
1139            .await
1140    }
1141
1142    pub async fn post_servers_server_files_search_with(
1143        &self,
1144        server: uuid::Uuid,
1145        data: &super::servers_server_files_search::post::RequestBody,
1146        extra: &super::servers_server_files_search::post::Extra,
1147    ) -> Result<super::servers_server_files_search::post::Response, ApiHttpError> {
1148        request_impl(
1149            self,
1150            Method::POST,
1151            format!("/api/servers/{server}/files/search"),
1152            Some(&ServersServerFilesSearchPostBody {
1153                inner: data,
1154                match_context: &extra.match_context,
1155            }),
1156            None,
1157        )
1158        .await
1159    }
1160
1161    pub async fn post_servers_server_files_sqlite_query(
1162        &self,
1163        server: uuid::Uuid,
1164        data: &super::servers_server_files_sqlite_query::post::RequestBody,
1165    ) -> Result<super::servers_server_files_sqlite_query::post::Response, ApiHttpError> {
1166        request_impl(
1167            self,
1168            Method::POST,
1169            format!("/api/servers/{server}/files/sqlite-query"),
1170            Some(&ServersServerFilesSqliteQueryPostBody {
1171                inner: data,
1172                ignored: &self.ignored,
1173            }),
1174            None,
1175        )
1176        .await
1177    }
1178
1179    pub async fn post_servers_server_files_stat(
1180        &self,
1181        server: uuid::Uuid,
1182        data: &super::servers_server_files_stat::post::RequestBody,
1183    ) -> Result<super::servers_server_files_stat::post::Response, ApiHttpError> {
1184        request_impl(
1185            self,
1186            Method::POST,
1187            format!("/api/servers/{server}/files/stat"),
1188            Some(&ServersServerFilesStatPostBody {
1189                inner: data,
1190                ignored: &self.ignored,
1191            }),
1192            None,
1193        )
1194        .await
1195    }
1196
1197    pub async fn get_servers_server_files_trash(
1198        &self,
1199        server: uuid::Uuid,
1200        query: &super::servers_server_files_trash::get::Query,
1201    ) -> Result<super::servers_server_files_trash::get::Response, ApiHttpError> {
1202        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
1203        if let Some(value) = &query.ignored {
1204            for value in value {
1205                query_parts.push(format!("ignored={}", urlencoding::encode(value)).into());
1206            }
1207        }
1208        if let Some(value) = query.per_page {
1209            query_parts.push(format!("per_page={}", value).into());
1210        }
1211        if let Some(value) = query.page {
1212            query_parts.push(format!("page={}", value).into());
1213        }
1214        let query = if query_parts.is_empty() {
1215            String::new()
1216        } else {
1217            format!("?{}", query_parts.join("&"))
1218        };
1219        request_impl(
1220            self,
1221            Method::GET,
1222            format!("/api/servers/{server}/files/trash{query}"),
1223            None::<&()>,
1224            None,
1225        )
1226        .await
1227    }
1228
1229    pub async fn delete_servers_server_files_trash(
1230        &self,
1231        server: uuid::Uuid,
1232        query: &super::servers_server_files_trash::delete::Query,
1233    ) -> Result<super::servers_server_files_trash::delete::Response, ApiHttpError> {
1234        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
1235        if let Some(value) = &query.ignored {
1236            for value in value {
1237                query_parts.push(format!("ignored={}", urlencoding::encode(value)).into());
1238            }
1239        }
1240        let query = if query_parts.is_empty() {
1241            String::new()
1242        } else {
1243            format!("?{}", query_parts.join("&"))
1244        };
1245        request_impl(
1246            self,
1247            Method::DELETE,
1248            format!("/api/servers/{server}/files/trash{query}"),
1249            None::<&()>,
1250            None,
1251        )
1252        .await
1253    }
1254
1255    pub async fn post_servers_server_files_trash(
1256        &self,
1257        server: uuid::Uuid,
1258        data: &super::servers_server_files_trash::post::RequestBody,
1259    ) -> Result<super::servers_server_files_trash::post::Response, ApiHttpError> {
1260        request_impl(
1261            self,
1262            Method::POST,
1263            format!("/api/servers/{server}/files/trash"),
1264            Some(&ServersServerFilesTrashPostBody {
1265                inner: data,
1266                ignored: &self.ignored,
1267            }),
1268            None,
1269        )
1270        .await
1271    }
1272
1273    pub async fn post_servers_server_files_trash_purge(
1274        &self,
1275        server: uuid::Uuid,
1276        data: &super::servers_server_files_trash_purge::post::RequestBody,
1277    ) -> Result<super::servers_server_files_trash_purge::post::Response, ApiHttpError> {
1278        request_impl(
1279            self,
1280            Method::POST,
1281            format!("/api/servers/{server}/files/trash/purge"),
1282            Some(&ServersServerFilesTrashPurgePostBody {
1283                inner: data,
1284                ignored: &self.ignored,
1285            }),
1286            None,
1287        )
1288        .await
1289    }
1290
1291    pub async fn post_servers_server_files_trash_restore(
1292        &self,
1293        server: uuid::Uuid,
1294        data: &super::servers_server_files_trash_restore::post::RequestBody,
1295    ) -> Result<super::servers_server_files_trash_restore::post::Response, ApiHttpError> {
1296        request_impl(
1297            self,
1298            Method::POST,
1299            format!("/api/servers/{server}/files/trash/restore"),
1300            Some(&ServersServerFilesTrashRestorePostBody {
1301                inner: data,
1302                ignored: &self.ignored,
1303            }),
1304            None,
1305        )
1306        .await
1307    }
1308
1309    pub async fn post_servers_server_files_write(
1310        &self,
1311        server: uuid::Uuid,
1312        data: super::servers_server_files_write::post::RequestBody,
1313        query: &super::servers_server_files_write::post::Query,
1314    ) -> Result<super::servers_server_files_write::post::Response, ApiHttpError> {
1315        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
1316        if let Some(value) = &query.file {
1317            query_parts.push(format!("file={}", urlencoding::encode(value)).into());
1318        }
1319        if let Some(value) = query.user {
1320            query_parts.push(format!("user={}", value).into());
1321        }
1322        if let Some(value) = &query.ignored {
1323            for value in value {
1324                query_parts.push(format!("ignored={}", urlencoding::encode(value)).into());
1325            }
1326        }
1327        let query = if query_parts.is_empty() {
1328            String::new()
1329        } else {
1330            format!("?{}", query_parts.join("&"))
1331        };
1332        request_impl(
1333            self,
1334            Method::POST,
1335            format!("/api/servers/{server}/files/write{query}"),
1336            None::<&()>,
1337            Some(data),
1338        )
1339        .await
1340    }
1341
1342    pub async fn post_servers_server_install_abort(
1343        &self,
1344        server: uuid::Uuid,
1345    ) -> Result<super::servers_server_install_abort::post::Response, ApiHttpError> {
1346        request_impl(
1347            self,
1348            Method::POST,
1349            format!("/api/servers/{server}/install/abort"),
1350            None::<&()>,
1351            None,
1352        )
1353        .await
1354    }
1355
1356    pub async fn get_servers_server_logs(
1357        &self,
1358        server: uuid::Uuid,
1359        query: &super::servers_server_logs::get::Query,
1360    ) -> Result<super::servers_server_logs::get::Response, ApiHttpError> {
1361        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
1362        if let Some(value) = query.lines {
1363            query_parts.push(format!("lines={}", value).into());
1364        }
1365        let query = if query_parts.is_empty() {
1366            String::new()
1367        } else {
1368            format!("?{}", query_parts.join("&"))
1369        };
1370        request_impl(
1371            self,
1372            Method::GET,
1373            format!("/api/servers/{server}/logs{query}"),
1374            None::<&()>,
1375            None,
1376        )
1377        .await
1378    }
1379
1380    pub async fn get_servers_server_logs_install(
1381        &self,
1382        server: uuid::Uuid,
1383        query: &super::servers_server_logs_install::get::Query,
1384    ) -> Result<super::servers_server_logs_install::get::Response, ApiHttpError> {
1385        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
1386        if let Some(value) = query.lines {
1387            query_parts.push(format!("lines={}", value).into());
1388        }
1389        let query = if query_parts.is_empty() {
1390            String::new()
1391        } else {
1392            format!("?{}", query_parts.join("&"))
1393        };
1394        request_impl(
1395            self,
1396            Method::GET,
1397            format!("/api/servers/{server}/logs/install{query}"),
1398            None::<&()>,
1399            None,
1400        )
1401        .await
1402    }
1403
1404    pub async fn post_servers_server_power(
1405        &self,
1406        server: uuid::Uuid,
1407        data: &super::servers_server_power::post::RequestBody,
1408    ) -> Result<super::servers_server_power::post::Response, ApiHttpError> {
1409        request_impl(
1410            self,
1411            Method::POST,
1412            format!("/api/servers/{server}/power"),
1413            Some(data),
1414            None,
1415        )
1416        .await
1417    }
1418
1419    pub async fn post_servers_server_reinstall(
1420        &self,
1421        server: uuid::Uuid,
1422        data: &super::servers_server_reinstall::post::RequestBody,
1423    ) -> Result<super::servers_server_reinstall::post::Response, ApiHttpError> {
1424        self.post_servers_server_reinstall_with(server, data, &Default::default())
1425            .await
1426    }
1427
1428    pub async fn post_servers_server_reinstall_with(
1429        &self,
1430        server: uuid::Uuid,
1431        data: &super::servers_server_reinstall::post::RequestBody,
1432        extra: &super::servers_server_reinstall::post::Extra,
1433    ) -> Result<super::servers_server_reinstall::post::Response, ApiHttpError> {
1434        request_impl(
1435            self,
1436            Method::POST,
1437            format!("/api/servers/{server}/reinstall"),
1438            Some(&ServersServerReinstallPostBody {
1439                inner: data,
1440                start_on_completion: &extra.start_on_completion,
1441            }),
1442            None,
1443        )
1444        .await
1445    }
1446
1447    pub async fn get_servers_server_schedules_schedule(
1448        &self,
1449        server: uuid::Uuid,
1450        schedule: uuid::Uuid,
1451    ) -> Result<super::servers_server_schedules_schedule::get::Response, ApiHttpError> {
1452        request_impl(
1453            self,
1454            Method::GET,
1455            format!("/api/servers/{server}/schedules/{schedule}"),
1456            None::<&()>,
1457            None,
1458        )
1459        .await
1460    }
1461
1462    pub async fn post_servers_server_schedules_schedule_abort(
1463        &self,
1464        server: uuid::Uuid,
1465        schedule: uuid::Uuid,
1466    ) -> Result<super::servers_server_schedules_schedule_abort::post::Response, ApiHttpError> {
1467        request_impl(
1468            self,
1469            Method::POST,
1470            format!("/api/servers/{server}/schedules/{schedule}/abort"),
1471            None::<&()>,
1472            None,
1473        )
1474        .await
1475    }
1476
1477    pub async fn post_servers_server_schedules_schedule_trigger(
1478        &self,
1479        server: uuid::Uuid,
1480        schedule: uuid::Uuid,
1481        data: &super::servers_server_schedules_schedule_trigger::post::RequestBody,
1482    ) -> Result<super::servers_server_schedules_schedule_trigger::post::Response, ApiHttpError>
1483    {
1484        request_impl(
1485            self,
1486            Method::POST,
1487            format!("/api/servers/{server}/schedules/{schedule}/trigger"),
1488            Some(data),
1489            None,
1490        )
1491        .await
1492    }
1493
1494    pub async fn post_servers_server_script(
1495        &self,
1496        server: uuid::Uuid,
1497        data: &super::servers_server_script::post::RequestBody,
1498    ) -> Result<super::servers_server_script::post::Response, ApiHttpError> {
1499        request_impl(
1500            self,
1501            Method::POST,
1502            format!("/api/servers/{server}/script"),
1503            Some(data),
1504            None,
1505        )
1506        .await
1507    }
1508
1509    pub async fn post_servers_server_sync(
1510        &self,
1511        server: uuid::Uuid,
1512        data: &super::servers_server_sync::post::RequestBody,
1513    ) -> Result<super::servers_server_sync::post::Response, ApiHttpError> {
1514        request_impl(
1515            self,
1516            Method::POST,
1517            format!("/api/servers/{server}/sync"),
1518            Some(data),
1519            None,
1520        )
1521        .await
1522    }
1523
1524    pub async fn delete_servers_server_transfer(
1525        &self,
1526        server: uuid::Uuid,
1527    ) -> Result<super::servers_server_transfer::delete::Response, ApiHttpError> {
1528        request_impl(
1529            self,
1530            Method::DELETE,
1531            format!("/api/servers/{server}/transfer"),
1532            None::<&()>,
1533            None,
1534        )
1535        .await
1536    }
1537
1538    pub async fn post_servers_server_transfer(
1539        &self,
1540        server: uuid::Uuid,
1541        data: &super::servers_server_transfer::post::RequestBody,
1542    ) -> Result<super::servers_server_transfer::post::Response, ApiHttpError> {
1543        request_impl(
1544            self,
1545            Method::POST,
1546            format!("/api/servers/{server}/transfer"),
1547            Some(data),
1548            None,
1549        )
1550        .await
1551    }
1552
1553    pub async fn get_servers_server_utilization(
1554        &self,
1555        server: uuid::Uuid,
1556    ) -> Result<super::servers_server_utilization::get::Response, ApiHttpError> {
1557        request_impl(
1558            self,
1559            Method::GET,
1560            format!("/api/servers/{server}/utilization"),
1561            None::<&()>,
1562            None,
1563        )
1564        .await
1565    }
1566
1567    pub async fn get_servers_server_version(
1568        &self,
1569        server: uuid::Uuid,
1570        query: &super::servers_server_version::get::Query,
1571    ) -> Result<super::servers_server_version::get::Response, ApiHttpError> {
1572        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
1573        if let Some(value) = query.game {
1574            query_parts.push(format!("game={}", value).into());
1575        }
1576        let query = if query_parts.is_empty() {
1577            String::new()
1578        } else {
1579            format!("?{}", query_parts.join("&"))
1580        };
1581        request_impl(
1582            self,
1583            Method::GET,
1584            format!("/api/servers/{server}/version{query}"),
1585            None::<&()>,
1586            None,
1587        )
1588        .await
1589    }
1590
1591    pub async fn post_servers_server_ws_broadcast(
1592        &self,
1593        server: uuid::Uuid,
1594        data: &super::servers_server_ws_broadcast::post::RequestBody,
1595    ) -> Result<super::servers_server_ws_broadcast::post::Response, ApiHttpError> {
1596        request_impl(
1597            self,
1598            Method::POST,
1599            format!("/api/servers/{server}/ws/broadcast"),
1600            Some(data),
1601            None,
1602        )
1603        .await
1604    }
1605
1606    pub async fn post_servers_server_ws_deny(
1607        &self,
1608        server: uuid::Uuid,
1609        data: &super::servers_server_ws_deny::post::RequestBody,
1610    ) -> Result<super::servers_server_ws_deny::post::Response, ApiHttpError> {
1611        request_impl(
1612            self,
1613            Method::POST,
1614            format!("/api/servers/{server}/ws/deny"),
1615            Some(data),
1616            None,
1617        )
1618        .await
1619    }
1620
1621    pub async fn post_servers_server_ws_permissions(
1622        &self,
1623        server: uuid::Uuid,
1624        data: &super::servers_server_ws_permissions::post::RequestBody,
1625    ) -> Result<super::servers_server_ws_permissions::post::Response, ApiHttpError> {
1626        request_impl(
1627            self,
1628            Method::POST,
1629            format!("/api/servers/{server}/ws/permissions"),
1630            Some(data),
1631            None,
1632        )
1633        .await
1634    }
1635
1636    pub async fn get_system(&self) -> Result<super::system::get::Response, ApiHttpError> {
1637        request_impl(self, Method::GET, "/api/system", None::<&()>, None).await
1638    }
1639
1640    pub async fn post_system_backups_test(
1641        &self,
1642        data: &super::system_backups_test::post::RequestBody,
1643    ) -> Result<super::system_backups_test::post::Response, ApiHttpError> {
1644        request_impl(
1645            self,
1646            Method::POST,
1647            "/api/system/backups/test",
1648            Some(data),
1649            None,
1650        )
1651        .await
1652    }
1653
1654    pub async fn get_system_config(
1655        &self,
1656    ) -> Result<super::system_config::get::Response, ApiHttpError> {
1657        request_impl(self, Method::GET, "/api/system/config", None::<&()>, None).await
1658    }
1659
1660    pub async fn get_system_ips(&self) -> Result<super::system_ips::get::Response, ApiHttpError> {
1661        request_impl(self, Method::GET, "/api/system/ips", None::<&()>, None).await
1662    }
1663
1664    pub async fn get_system_logs(&self) -> Result<super::system_logs::get::Response, ApiHttpError> {
1665        request_impl(self, Method::GET, "/api/system/logs", None::<&()>, None).await
1666    }
1667
1668    pub async fn get_system_logs_file(
1669        &self,
1670        file: &str,
1671        query: &super::system_logs_file::get::Query,
1672    ) -> Result<super::system_logs_file::get::Response, ApiHttpError> {
1673        let mut query_parts: Vec<compact_str::CompactString> = Vec::new();
1674        if let Some(value) = query.lines {
1675            query_parts.push(format!("lines={}", value).into());
1676        }
1677        let query = if query_parts.is_empty() {
1678            String::new()
1679        } else {
1680            format!("?{}", query_parts.join("&"))
1681        };
1682        request_impl(
1683            self,
1684            Method::GET,
1685            format!("/api/system/logs/{file}{query}"),
1686            None::<&()>,
1687            None,
1688        )
1689        .await
1690    }
1691
1692    pub async fn get_system_overview(
1693        &self,
1694    ) -> Result<super::system_overview::get::Response, ApiHttpError> {
1695        request_impl(self, Method::GET, "/api/system/overview", None::<&()>, None).await
1696    }
1697
1698    pub async fn get_system_restic_prune(
1699        &self,
1700    ) -> Result<super::system_restic_prune::get::Response, ApiHttpError> {
1701        request_impl(
1702            self,
1703            Method::GET,
1704            "/api/system/restic/prune",
1705            None::<&()>,
1706            None,
1707        )
1708        .await
1709    }
1710
1711    pub async fn post_system_restic_prune(
1712        &self,
1713        data: &super::system_restic_prune::post::RequestBody,
1714    ) -> Result<super::system_restic_prune::post::Response, ApiHttpError> {
1715        request_impl(
1716            self,
1717            Method::POST,
1718            "/api/system/restic/prune",
1719            Some(data),
1720            None,
1721        )
1722        .await
1723    }
1724
1725    pub async fn get_system_restic_stats(
1726        &self,
1727    ) -> Result<super::system_restic_stats::get::Response, ApiHttpError> {
1728        request_impl(
1729            self,
1730            Method::GET,
1731            "/api/system/restic/stats",
1732            None::<&()>,
1733            None,
1734        )
1735        .await
1736    }
1737
1738    pub async fn post_system_restic_stats(
1739        &self,
1740        data: &super::system_restic_stats::post::RequestBody,
1741    ) -> Result<super::system_restic_stats::post::Response, ApiHttpError> {
1742        request_impl(
1743            self,
1744            Method::POST,
1745            "/api/system/restic/stats",
1746            Some(data),
1747            None,
1748        )
1749        .await
1750    }
1751
1752    pub async fn get_system_restic_unlock(
1753        &self,
1754    ) -> Result<super::system_restic_unlock::get::Response, ApiHttpError> {
1755        request_impl(
1756            self,
1757            Method::GET,
1758            "/api/system/restic/unlock",
1759            None::<&()>,
1760            None,
1761        )
1762        .await
1763    }
1764
1765    pub async fn post_system_restic_unlock(
1766        &self,
1767        data: &super::system_restic_unlock::post::RequestBody,
1768    ) -> Result<super::system_restic_unlock::post::Response, ApiHttpError> {
1769        request_impl(
1770            self,
1771            Method::POST,
1772            "/api/system/restic/unlock",
1773            Some(data),
1774            None,
1775        )
1776        .await
1777    }
1778
1779    pub async fn get_system_stats(
1780        &self,
1781    ) -> Result<super::system_stats::get::Response, ApiHttpError> {
1782        request_impl(self, Method::GET, "/api/system/stats", None::<&()>, None).await
1783    }
1784
1785    pub async fn post_system_upgrade(
1786        &self,
1787        data: &super::system_upgrade::post::RequestBody,
1788    ) -> Result<super::system_upgrade::post::Response, ApiHttpError> {
1789        request_impl(self, Method::POST, "/api/system/upgrade", Some(data), None).await
1790    }
1791
1792    pub async fn get_transfers(&self) -> Result<super::transfers::get::Response, ApiHttpError> {
1793        request_impl(self, Method::GET, "/api/transfers", None::<&()>, None).await
1794    }
1795
1796    pub async fn post_transfers(&self) -> Result<super::transfers::post::Response, ApiHttpError> {
1797        request_impl(self, Method::POST, "/api/transfers", None::<&()>, None).await
1798    }
1799
1800    pub async fn get_transfers_capabilities(
1801        &self,
1802    ) -> Result<super::transfers_capabilities::get::Response, ApiHttpError> {
1803        request_impl(
1804            self,
1805            Method::GET,
1806            "/api/transfers/capabilities",
1807            None::<&()>,
1808            None,
1809        )
1810        .await
1811    }
1812
1813    pub async fn post_transfers_files(
1814        &self,
1815    ) -> Result<super::transfers_files::post::Response, ApiHttpError> {
1816        request_impl(
1817            self,
1818            Method::POST,
1819            "/api/transfers/files",
1820            None::<&()>,
1821            None,
1822        )
1823        .await
1824    }
1825
1826    pub async fn post_transfers_files_stat(
1827        &self,
1828        data: &super::transfers_files_stat::post::RequestBody,
1829    ) -> Result<super::transfers_files_stat::post::Response, ApiHttpError> {
1830        request_impl(
1831            self,
1832            Method::POST,
1833            "/api/transfers/files/stat",
1834            Some(data),
1835            None,
1836        )
1837        .await
1838    }
1839
1840    pub async fn get_transfers_query(
1841        &self,
1842    ) -> Result<super::transfers_query::get::Response, ApiHttpError> {
1843        request_impl(self, Method::GET, "/api/transfers/query", None::<&()>, None).await
1844    }
1845
1846    pub async fn delete_transfers_server(
1847        &self,
1848        server: uuid::Uuid,
1849    ) -> Result<super::transfers_server::delete::Response, ApiHttpError> {
1850        request_impl(
1851            self,
1852            Method::DELETE,
1853            format!("/api/transfers/{server}"),
1854            None::<&()>,
1855            None,
1856        )
1857        .await
1858    }
1859
1860    pub async fn post_update(
1861        &self,
1862        data: &super::update::post::RequestBody,
1863    ) -> Result<super::update::post::Response, ApiHttpError> {
1864        request_impl(self, Method::POST, "/api/update", Some(data), None).await
1865    }
1866}
1867
1868#[derive(Serialize)]
1869struct BackupsBackupExportPostBody<'a> {
1870    #[serde(flatten)]
1871    inner: &'a super::backups_backup_export::post::RequestBody,
1872    ignored: &'a Vec<compact_str::CompactString>,
1873}
1874
1875#[derive(Serialize)]
1876struct ServersServerFilesChmodPostBody<'a> {
1877    #[serde(flatten)]
1878    inner: &'a super::servers_server_files_chmod::post::RequestBody,
1879    ignored: &'a Vec<compact_str::CompactString>,
1880}
1881
1882#[derive(Serialize)]
1883struct ServersServerFilesCompressPostBody<'a> {
1884    #[serde(flatten)]
1885    inner: &'a super::servers_server_files_compress::post::RequestBody,
1886    ignored: &'a Vec<compact_str::CompactString>,
1887}
1888
1889#[derive(Serialize)]
1890struct ServersServerFilesCopyPostBody<'a> {
1891    #[serde(flatten)]
1892    inner: &'a super::servers_server_files_copy::post::RequestBody,
1893    ignored: &'a Vec<compact_str::CompactString>,
1894}
1895
1896#[derive(Serialize)]
1897struct ServersServerFilesCopyManyPostBody<'a> {
1898    #[serde(flatten)]
1899    inner: &'a super::servers_server_files_copy_many::post::RequestBody,
1900    ignored: &'a Vec<compact_str::CompactString>,
1901}
1902
1903#[derive(Serialize)]
1904struct ServersServerFilesCopyRemotePostBody<'a> {
1905    #[serde(flatten)]
1906    inner: &'a super::servers_server_files_copy_remote::post::RequestBody,
1907    ignored: &'a Vec<compact_str::CompactString>,
1908    destination_ignored: &'a Vec<compact_str::CompactString>,
1909    overwrite: &'a bool,
1910}
1911
1912#[derive(Serialize)]
1913struct ServersServerFilesCreateDirectoryPostBody<'a> {
1914    #[serde(flatten)]
1915    inner: &'a super::servers_server_files_create_directory::post::RequestBody,
1916    ignored: &'a Vec<compact_str::CompactString>,
1917}
1918
1919#[derive(Serialize)]
1920struct ServersServerFilesCreateSymlinkPostBody<'a> {
1921    #[serde(flatten)]
1922    inner: &'a super::servers_server_files_create_symlink::post::RequestBody,
1923    ignored: &'a Vec<compact_str::CompactString>,
1924}
1925
1926#[derive(Serialize)]
1927struct ServersServerFilesDecompressPostBody<'a> {
1928    #[serde(flatten)]
1929    inner: &'a super::servers_server_files_decompress::post::RequestBody,
1930    ignored: &'a Vec<compact_str::CompactString>,
1931}
1932
1933#[derive(Serialize)]
1934struct ServersServerFilesDeletePostBody<'a> {
1935    #[serde(flatten)]
1936    inner: &'a super::servers_server_files_delete::post::RequestBody,
1937    ignored: &'a Vec<compact_str::CompactString>,
1938}
1939
1940#[derive(Serialize)]
1941struct ServersServerFilesIgnoreMatchesPostBody<'a> {
1942    #[serde(flatten)]
1943    inner: &'a super::servers_server_files_ignore_matches::post::RequestBody,
1944    ignored: &'a Vec<compact_str::CompactString>,
1945}
1946
1947#[derive(Serialize)]
1948struct ServersServerFilesPullPostBody<'a> {
1949    #[serde(flatten)]
1950    inner: &'a super::servers_server_files_pull::post::RequestBody,
1951    ignored: &'a Vec<compact_str::CompactString>,
1952}
1953
1954#[derive(Serialize)]
1955struct ServersServerFilesRenamePutBody<'a> {
1956    #[serde(flatten)]
1957    inner: &'a super::servers_server_files_rename::put::RequestBody,
1958    ignored: &'a Vec<compact_str::CompactString>,
1959    create_directories: &'a bool,
1960}
1961
1962#[derive(Serialize)]
1963struct ServersServerFilesSearchPostBody<'a> {
1964    #[serde(flatten)]
1965    inner: &'a super::servers_server_files_search::post::RequestBody,
1966    match_context: &'a Option<super::servers_server_files_search::post::ExtraMatchContext>,
1967}
1968
1969#[derive(Serialize)]
1970struct ServersServerFilesSqliteQueryPostBody<'a> {
1971    #[serde(flatten)]
1972    inner: &'a super::servers_server_files_sqlite_query::post::RequestBody,
1973    ignored: &'a Vec<compact_str::CompactString>,
1974}
1975
1976#[derive(Serialize)]
1977struct ServersServerFilesStatPostBody<'a> {
1978    #[serde(flatten)]
1979    inner: &'a super::servers_server_files_stat::post::RequestBody,
1980    ignored: &'a Vec<compact_str::CompactString>,
1981}
1982
1983#[derive(Serialize)]
1984struct ServersServerFilesTrashPostBody<'a> {
1985    #[serde(flatten)]
1986    inner: &'a super::servers_server_files_trash::post::RequestBody,
1987    ignored: &'a Vec<compact_str::CompactString>,
1988}
1989
1990#[derive(Serialize)]
1991struct ServersServerFilesTrashPurgePostBody<'a> {
1992    #[serde(flatten)]
1993    inner: &'a super::servers_server_files_trash_purge::post::RequestBody,
1994    ignored: &'a Vec<compact_str::CompactString>,
1995}
1996
1997#[derive(Serialize)]
1998struct ServersServerFilesTrashRestorePostBody<'a> {
1999    #[serde(flatten)]
2000    inner: &'a super::servers_server_files_trash_restore::post::RequestBody,
2001    ignored: &'a Vec<compact_str::CompactString>,
2002}
2003
2004#[derive(Serialize)]
2005struct ServersServerReinstallPostBody<'a> {
2006    #[serde(flatten)]
2007    inner: &'a super::servers_server_reinstall::post::RequestBody,
2008    start_on_completion: &'a bool,
2009}
wings_api/client.rs

wings_api/
client.rs
