wings_api/
client.rs

1// This file is auto-generated from OpenAPI spec. Do not edit manually.
2use super::*;
3use futures_util::TryStreamExt;
4use reqwest::{Client, Method, StatusCode};
5use serde::de::DeserializeOwned;
6use std::{
7    pin::Pin,
8    sync::LazyLock,
9    task::{Context, Poll},
10};
11use tokio::io::AsyncRead;
12use tokio_tungstenite::tungstenite::{Error, client::IntoClientRequest, http::HeaderValue};
13
14static CLIENT: LazyLock<Client> = LazyLock::new(|| {
15    Client::builder()
16        .user_agent("Calagopus Panel")
17        .build()
18        .expect("Failed to create reqwest client")
19});
20
21#[derive(Debug)]
22pub enum ApiHttpError {
23    Http(StatusCode, super::ApiError),
24    Reqwest(reqwest::Error),
25    WebSocket(tokio_tungstenite::tungstenite::Error),
26    MsgpackEncode(rmp_serde::encode::Error),
27    MsgpackDecode(rmp_serde::decode::Error),
28}
29
30impl From<ApiHttpError> for anyhow::Error {
31    fn from(value: ApiHttpError) -> Self {
32        match value {
33            ApiHttpError::Http(status, err) => {
34                anyhow::anyhow!("wings api status code {status}: {}", err.error)
35            }
36            ApiHttpError::Reqwest(err) => anyhow::anyhow!(err),
37            ApiHttpError::WebSocket(err) => anyhow::anyhow!(err),
38            ApiHttpError::MsgpackEncode(err) => anyhow::anyhow!(err),
39            ApiHttpError::MsgpackDecode(err) => anyhow::anyhow!(err),
40        }
41    }
42}
43
44pub struct AsyncResponseReader(Box<dyn AsyncRead + Send + Unpin>);
45
46impl AsyncRead for AsyncResponseReader {
47    fn poll_read(
48        mut self: Pin<&mut Self>,
49        cx: &mut Context<'_>,
50        buf: &mut tokio::io::ReadBuf<'_>,
51    ) -> Poll<std::io::Result<()>> {
52        Pin::new(&mut self.0).poll_read(cx, buf)
53    }
54}
55
56impl<'de> Deserialize<'de> for AsyncResponseReader {
57    fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
58    where
59        D: serde::Deserializer<'de>,
60    {
61        Ok(Self(Box::new(tokio::io::empty())))
62    }
63}
64
65async fn request_impl<T: DeserializeOwned + 'static>(
66    client: &WingsClient,
67    method: Method,
68    endpoint: impl AsRef<str>,
69    body: Option<&impl Serialize>,
70    body_raw: Option<compact_str::CompactString>,
71) -> Result<T, ApiHttpError> {
72    let url = format!(
73        "{}{}",
74        client.base_url.trim_end_matches('/'),
75        endpoint.as_ref()
76    );
77    let mut request = CLIENT.request(method, &url);
78    request = request.header("Accept", "application/msgpack");
79
80    if !client.token.is_empty() {
81        request = request.header("Authorization", format!("Bearer {}", client.token));
82    }
83
84    if let Some(body) = body {
85        request = request.header("Content-Type", "application/msgpack");
86
87        let mut bytes = Vec::new();
88        let mut se = rmp_serde::Serializer::new(&mut bytes)
89            .with_struct_map()
90            .with_human_readable();
91        if let Err(err) = body.serialize(&mut se) {
92            return Err(ApiHttpError::MsgpackEncode(err));
93        }
94        request = request.body(bytes);
95    } else if let Some(body_raw) = body_raw {
96        request = request.body(Vec::from(body_raw));
97    }
98
99    match request.send().await {
100        Ok(response) => {
101            if response.status().is_success() {
102                if std::any::type_name::<T>() == std::any::type_name::<AsyncResponseReader>() {
103                    let stream = response.bytes_stream().map_err(|err| {
104                        std::io::Error::other(format!("failed to read multipart field: {err}"))
105                    });
106                    let stream_reader = tokio_util::io::StreamReader::new(stream);
107
108                    return Ok(*(Box::new(AsyncResponseReader(Box::new(stream_reader)))
109                        as Box<dyn std::any::Any>)
110                        .downcast::<T>()
111                        .unwrap());
112                }
113
114                match response.bytes().await {
115                    Ok(data) => {
116                        let mut de =
117                            rmp_serde::Deserializer::new(data.as_ref()).with_human_readable();
118                        match T::deserialize(&mut de) {
119                            Ok(data) => Ok(data),
120                            Err(err) => Err(ApiHttpError::MsgpackDecode(err)),
121                        }
122                    }
123                    Err(err) => Err(ApiHttpError::Reqwest(err)),
124                }
125            } else {
126                Err(ApiHttpError::Http(
127                    response.status(),
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 super::ApiError::deserialize(&mut de) {
133                                Ok(data) => data,
134                                Err(err) => super::ApiError {
135                                    error: err.to_string().into(),
136                                },
137                            }
138                        }
139                        Err(err) => super::ApiError {
140                            error: err.to_string().into(),
141                        },
142                    },
143                ))
144            }
145        }
146        Err(err) => Err(ApiHttpError::Reqwest(err)),
147    }
148}
149
150pub struct WingsClient {
151    base_url: String,
152    token: String,
153}
154
155impl WingsClient {
156    #[inline]
157    pub fn new(base_url: String, token: String) -> Self {
158        Self { base_url, token }
159    }
160
161    pub fn request_raw(
162        &self,
163        method: Method,
164        endpoint: impl AsRef<str>,
165    ) -> reqwest::RequestBuilder {
166        let url = format!(
167            "{}/{}",
168            self.base_url.trim_end_matches('/'),
169            endpoint.as_ref().trim_start_matches('/')
170        );
171        let mut request = CLIENT.request(method, &url);
172
173        if !self.token.is_empty() {
174            request = request.header("Authorization", format!("Bearer {}", self.token));
175        }
176
177        request
178    }
179
180    pub async fn open_websocket(
181        &self,
182        endpoint: impl AsRef<str>,
183        headers: reqwest::header::HeaderMap,
184    ) -> Result<
185        tokio_tungstenite::WebSocketStream<
186            tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,
187        >,
188        ApiHttpError,
189    > {
190        let url = format!(
191            "{}{}",
192            self.base_url.trim_end_matches('/'),
193            endpoint.as_ref()
194        );
195        let url = if let Some(rest) = url.strip_prefix("https://") {
196            format!("wss://{rest}")
197        } else if let Some(rest) = url.strip_prefix("http://") {
198            format!("ws://{rest}")
199        } else {
200            url
201        };
202
203        let mut request = url.into_client_request().map_err(ApiHttpError::WebSocket)?;
204
205        if !self.token.is_empty() {
206            let value = HeaderValue::from_str(&format!("Bearer {}", self.token))
207                .map_err(|err| ApiHttpError::WebSocket(Error::HttpFormat(err.into())))?;
208            request.headers_mut().insert("Authorization", value);
209        }
210
211        for (header, value) in headers {
212            let Some(header) = header else {
213                continue;
214            };
215            request.headers_mut().insert(header, value);
216        }
217
218        let (stream, _) = tokio_tungstenite::connect_async(request)
219            .await
220            .map_err(ApiHttpError::WebSocket)?;
221
222        Ok(stream)
223    }
224
225    pub async fn delete_backups_backup(
226        &self,
227        backup: uuid::Uuid,
228        data: &super::backups_backup::delete::RequestBody,
229    ) -> Result<super::backups_backup::delete::Response, ApiHttpError> {
230        request_impl(
231            self,
232            Method::DELETE,
233            format!("/api/backups/{backup}"),
234            Some(data),
235            None,
236        )
237        .await
238    }
239
240    pub async fn post_deauthorize_user(
241        &self,
242        data: &super::deauthorize_user::post::RequestBody,
243    ) -> Result<super::deauthorize_user::post::Response, ApiHttpError> {
244        request_impl(
245            self,
246            Method::POST,
247            "/api/deauthorize-user",
248            Some(data),
249            None,
250        )
251        .await
252    }
253
254    pub async fn get_servers(&self) -> Result<super::servers::get::Response, ApiHttpError> {
255        request_impl(self, Method::GET, "/api/servers", None::<&()>, None).await
256    }
257
258    pub async fn post_servers(
259        &self,
260        data: &super::servers::post::RequestBody,
261    ) -> Result<super::servers::post::Response, ApiHttpError> {
262        request_impl(self, Method::POST, "/api/servers", Some(data), None).await
263    }
264
265    pub async fn post_servers_power(
266        &self,
267        data: &super::servers_power::post::RequestBody,
268    ) -> Result<super::servers_power::post::Response, ApiHttpError> {
269        request_impl(self, Method::POST, "/api/servers/power", Some(data), None).await
270    }
271
272    pub async fn get_servers_utilization(
273        &self,
274    ) -> Result<super::servers_utilization::get::Response, ApiHttpError> {
275        request_impl(
276            self,
277            Method::GET,
278            "/api/servers/utilization",
279            None::<&()>,
280            None,
281        )
282        .await
283    }
284
285    pub async fn get_servers_server(
286        &self,
287        server: uuid::Uuid,
288    ) -> Result<super::servers_server::get::Response, ApiHttpError> {
289        request_impl(
290            self,
291            Method::GET,
292            format!("/api/servers/{server}"),
293            None::<&()>,
294            None,
295        )
296        .await
297    }
298
299    pub async fn delete_servers_server(
300        &self,
301        server: uuid::Uuid,
302    ) -> Result<super::servers_server::delete::Response, ApiHttpError> {
303        request_impl(
304            self,
305            Method::DELETE,
306            format!("/api/servers/{server}"),
307            None::<&()>,
308            None,
309        )
310        .await
311    }
312
313    pub async fn post_servers_server_backup(
314        &self,
315        server: uuid::Uuid,
316        data: &super::servers_server_backup::post::RequestBody,
317    ) -> Result<super::servers_server_backup::post::Response, ApiHttpError> {
318        request_impl(
319            self,
320            Method::POST,
321            format!("/api/servers/{server}/backup"),
322            Some(data),
323            None,
324        )
325        .await
326    }
327
328    pub async fn delete_servers_server_backup_backup(
329        &self,
330        server: uuid::Uuid,
331        backup: uuid::Uuid,
332    ) -> Result<super::servers_server_backup_backup::delete::Response, ApiHttpError> {
333        request_impl(
334            self,
335            Method::DELETE,
336            format!("/api/servers/{server}/backup/{backup}"),
337            None::<&()>,
338            None,
339        )
340        .await
341    }
342
343    pub async fn post_servers_server_backup_backup_restore(
344        &self,
345        server: uuid::Uuid,
346        backup: uuid::Uuid,
347        data: &super::servers_server_backup_backup_restore::post::RequestBody,
348    ) -> Result<super::servers_server_backup_backup_restore::post::Response, ApiHttpError> {
349        request_impl(
350            self,
351            Method::POST,
352            format!("/api/servers/{server}/backup/{backup}/restore"),
353            Some(data),
354            None,
355        )
356        .await
357    }
358
359    pub async fn post_servers_server_commands(
360        &self,
361        server: uuid::Uuid,
362        data: &super::servers_server_commands::post::RequestBody,
363    ) -> Result<super::servers_server_commands::post::Response, ApiHttpError> {
364        request_impl(
365            self,
366            Method::POST,
367            format!("/api/servers/{server}/commands"),
368            Some(data),
369            None,
370        )
371        .await
372    }
373
374    pub async fn post_servers_server_files_chmod(
375        &self,
376        server: uuid::Uuid,
377        data: &super::servers_server_files_chmod::post::RequestBody,
378    ) -> Result<super::servers_server_files_chmod::post::Response, ApiHttpError> {
379        request_impl(
380            self,
381            Method::POST,
382            format!("/api/servers/{server}/files/chmod"),
383            Some(data),
384            None,
385        )
386        .await
387    }
388
389    pub async fn post_servers_server_files_compress(
390        &self,
391        server: uuid::Uuid,
392        data: &super::servers_server_files_compress::post::RequestBody,
393    ) -> Result<super::servers_server_files_compress::post::Response, ApiHttpError> {
394        request_impl(
395            self,
396            Method::POST,
397            format!("/api/servers/{server}/files/compress"),
398            Some(data),
399            None,
400        )
401        .await
402    }
403
404    pub async fn get_servers_server_files_contents(
405        &self,
406        server: uuid::Uuid,
407        file: &str,
408        download: bool,
409        max_size: u64,
410    ) -> Result<super::servers_server_files_contents::get::Response, ApiHttpError> {
411        let file = urlencoding::encode(file);
412        request_impl(self, Method::GET, format!("/api/servers/{server}/files/contents?file={file}&download={download}&max_size={max_size}"), None::<&()>, None).await
413    }
414
415    pub async fn post_servers_server_files_copy(
416        &self,
417        server: uuid::Uuid,
418        data: &super::servers_server_files_copy::post::RequestBody,
419    ) -> Result<super::servers_server_files_copy::post::Response, ApiHttpError> {
420        request_impl(
421            self,
422            Method::POST,
423            format!("/api/servers/{server}/files/copy"),
424            Some(data),
425            None,
426        )
427        .await
428    }
429
430    pub async fn post_servers_server_files_copy_many(
431        &self,
432        server: uuid::Uuid,
433        data: &super::servers_server_files_copy_many::post::RequestBody,
434    ) -> Result<super::servers_server_files_copy_many::post::Response, ApiHttpError> {
435        request_impl(
436            self,
437            Method::POST,
438            format!("/api/servers/{server}/files/copy-many"),
439            Some(data),
440            None,
441        )
442        .await
443    }
444
445    pub async fn post_servers_server_files_copy_remote(
446        &self,
447        server: uuid::Uuid,
448        data: &super::servers_server_files_copy_remote::post::RequestBody,
449    ) -> Result<super::servers_server_files_copy_remote::post::Response, ApiHttpError> {
450        request_impl(
451            self,
452            Method::POST,
453            format!("/api/servers/{server}/files/copy-remote"),
454            Some(data),
455            None,
456        )
457        .await
458    }
459
460    pub async fn post_servers_server_files_create_directory(
461        &self,
462        server: uuid::Uuid,
463        data: &super::servers_server_files_create_directory::post::RequestBody,
464    ) -> Result<super::servers_server_files_create_directory::post::Response, ApiHttpError> {
465        request_impl(
466            self,
467            Method::POST,
468            format!("/api/servers/{server}/files/create-directory"),
469            Some(data),
470            None,
471        )
472        .await
473    }
474
475    pub async fn post_servers_server_files_decompress(
476        &self,
477        server: uuid::Uuid,
478        data: &super::servers_server_files_decompress::post::RequestBody,
479    ) -> Result<super::servers_server_files_decompress::post::Response, ApiHttpError> {
480        request_impl(
481            self,
482            Method::POST,
483            format!("/api/servers/{server}/files/decompress"),
484            Some(data),
485            None,
486        )
487        .await
488    }
489
490    pub async fn post_servers_server_files_delete(
491        &self,
492        server: uuid::Uuid,
493        data: &super::servers_server_files_delete::post::RequestBody,
494    ) -> Result<super::servers_server_files_delete::post::Response, ApiHttpError> {
495        request_impl(
496            self,
497            Method::POST,
498            format!("/api/servers/{server}/files/delete"),
499            Some(data),
500            None,
501        )
502        .await
503    }
504
505    pub async fn get_servers_server_files_fingerprints(
506        &self,
507        server: uuid::Uuid,
508        algorithm: Algorithm,
509        files: Vec<compact_str::CompactString>,
510    ) -> Result<super::servers_server_files_fingerprints::get::Response, ApiHttpError> {
511        let files = files
512            .into_iter()
513            .map(|s| urlencoding::encode(&s).into())
514            .collect::<Vec<compact_str::CompactString>>()
515            .join("&files=");
516        request_impl(
517            self,
518            Method::GET,
519            format!("/api/servers/{server}/files/fingerprints?algorithm={algorithm}&files={files}"),
520            None::<&()>,
521            None,
522        )
523        .await
524    }
525
526    pub async fn get_servers_server_files_largest_directories(
527        &self,
528        server: uuid::Uuid,
529        directory: &str,
530    ) -> Result<super::servers_server_files_largest_directories::get::Response, ApiHttpError> {
531        let directory = urlencoding::encode(directory);
532        request_impl(
533            self,
534            Method::GET,
535            format!("/api/servers/{server}/files/largest-directories?directory={directory}"),
536            None::<&()>,
537            None,
538        )
539        .await
540    }
541
542    pub async fn get_servers_server_files_list(
543        &self,
544        server: uuid::Uuid,
545        directory: &str,
546        ignored: Vec<compact_str::CompactString>,
547        per_page: u64,
548        page: u64,
549        sort: DirectorySortingMode,
550    ) -> Result<super::servers_server_files_list::get::Response, ApiHttpError> {
551        let directory = urlencoding::encode(directory);
552        let ignored = ignored
553            .into_iter()
554            .map(|s| urlencoding::encode(&s).into())
555            .collect::<Vec<compact_str::CompactString>>()
556            .join("&ignored=");
557        request_impl(self, Method::GET, format!("/api/servers/{server}/files/list?directory={directory}&ignored={ignored}&per_page={per_page}&page={page}&sort={sort}"), None::<&()>, None).await
558    }
559
560    pub async fn get_servers_server_files_list_directory(
561        &self,
562        server: uuid::Uuid,
563        directory: &str,
564    ) -> Result<super::servers_server_files_list_directory::get::Response, ApiHttpError> {
565        let directory = urlencoding::encode(directory);
566        request_impl(
567            self,
568            Method::GET,
569            format!("/api/servers/{server}/files/list-directory?directory={directory}"),
570            None::<&()>,
571            None,
572        )
573        .await
574    }
575
576    pub async fn get_servers_server_files_operations(
577        &self,
578        server: uuid::Uuid,
579    ) -> Result<super::servers_server_files_operations::get::Response, ApiHttpError> {
580        request_impl(
581            self,
582            Method::GET,
583            format!("/api/servers/{server}/files/operations"),
584            None::<&()>,
585            None,
586        )
587        .await
588    }
589
590    pub async fn delete_servers_server_files_operations_operation(
591        &self,
592        server: uuid::Uuid,
593        operation: uuid::Uuid,
594    ) -> Result<super::servers_server_files_operations_operation::delete::Response, ApiHttpError>
595    {
596        request_impl(
597            self,
598            Method::DELETE,
599            format!("/api/servers/{server}/files/operations/{operation}"),
600            None::<&()>,
601            None,
602        )
603        .await
604    }
605
606    pub async fn get_servers_server_files_pull(
607        &self,
608        server: uuid::Uuid,
609    ) -> Result<super::servers_server_files_pull::get::Response, ApiHttpError> {
610        request_impl(
611            self,
612            Method::GET,
613            format!("/api/servers/{server}/files/pull"),
614            None::<&()>,
615            None,
616        )
617        .await
618    }
619
620    pub async fn post_servers_server_files_pull(
621        &self,
622        server: uuid::Uuid,
623        data: &super::servers_server_files_pull::post::RequestBody,
624    ) -> Result<super::servers_server_files_pull::post::Response, ApiHttpError> {
625        request_impl(
626            self,
627            Method::POST,
628            format!("/api/servers/{server}/files/pull"),
629            Some(data),
630            None,
631        )
632        .await
633    }
634
635    pub async fn post_servers_server_files_pull_query(
636        &self,
637        server: uuid::Uuid,
638        data: &super::servers_server_files_pull_query::post::RequestBody,
639    ) -> Result<super::servers_server_files_pull_query::post::Response, ApiHttpError> {
640        request_impl(
641            self,
642            Method::POST,
643            format!("/api/servers/{server}/files/pull/query"),
644            Some(data),
645            None,
646        )
647        .await
648    }
649
650    pub async fn delete_servers_server_files_pull_pull(
651        &self,
652        server: uuid::Uuid,
653        pull: uuid::Uuid,
654    ) -> Result<super::servers_server_files_pull_pull::delete::Response, ApiHttpError> {
655        request_impl(
656            self,
657            Method::DELETE,
658            format!("/api/servers/{server}/files/pull/{pull}"),
659            None::<&()>,
660            None,
661        )
662        .await
663    }
664
665    pub async fn put_servers_server_files_rename(
666        &self,
667        server: uuid::Uuid,
668        data: &super::servers_server_files_rename::put::RequestBody,
669    ) -> Result<super::servers_server_files_rename::put::Response, ApiHttpError> {
670        request_impl(
671            self,
672            Method::PUT,
673            format!("/api/servers/{server}/files/rename"),
674            Some(data),
675            None,
676        )
677        .await
678    }
679
680    pub async fn get_servers_server_files_revisions(
681        &self,
682        server: uuid::Uuid,
683        file: &str,
684    ) -> Result<super::servers_server_files_revisions::get::Response, ApiHttpError> {
685        let file = urlencoding::encode(file);
686        request_impl(
687            self,
688            Method::GET,
689            format!("/api/servers/{server}/files/revisions?file={file}"),
690            None::<&()>,
691            None,
692        )
693        .await
694    }
695
696    pub async fn get_servers_server_files_revisions_revision(
697        &self,
698        server: uuid::Uuid,
699        revision: i64,
700    ) -> Result<super::servers_server_files_revisions_revision::get::Response, ApiHttpError> {
701        request_impl(
702            self,
703            Method::GET,
704            format!("/api/servers/{server}/files/revisions/{revision}"),
705            None::<&()>,
706            None,
707        )
708        .await
709    }
710
711    pub async fn post_servers_server_files_search(
712        &self,
713        server: uuid::Uuid,
714        data: &super::servers_server_files_search::post::RequestBody,
715    ) -> Result<super::servers_server_files_search::post::Response, ApiHttpError> {
716        request_impl(
717            self,
718            Method::POST,
719            format!("/api/servers/{server}/files/search"),
720            Some(data),
721            None,
722        )
723        .await
724    }
725
726    pub async fn post_servers_server_files_write(
727        &self,
728        server: uuid::Uuid,
729        file: &str,
730        user: uuid::Uuid,
731        data: super::servers_server_files_write::post::RequestBody,
732    ) -> Result<super::servers_server_files_write::post::Response, ApiHttpError> {
733        let file = urlencoding::encode(file);
734        request_impl(
735            self,
736            Method::POST,
737            format!("/api/servers/{server}/files/write?file={file}&user={user}"),
738            None::<&()>,
739            Some(data),
740        )
741        .await
742    }
743
744    pub async fn post_servers_server_install_abort(
745        &self,
746        server: uuid::Uuid,
747    ) -> Result<super::servers_server_install_abort::post::Response, ApiHttpError> {
748        request_impl(
749            self,
750            Method::POST,
751            format!("/api/servers/{server}/install/abort"),
752            None::<&()>,
753            None,
754        )
755        .await
756    }
757
758    pub async fn get_servers_server_logs(
759        &self,
760        server: uuid::Uuid,
761        lines: u64,
762    ) -> Result<super::servers_server_logs::get::Response, ApiHttpError> {
763        request_impl(
764            self,
765            Method::GET,
766            format!("/api/servers/{server}/logs?lines={lines}"),
767            None::<&()>,
768            None,
769        )
770        .await
771    }
772
773    pub async fn get_servers_server_logs_install(
774        &self,
775        server: uuid::Uuid,
776        lines: u64,
777    ) -> Result<super::servers_server_logs_install::get::Response, ApiHttpError> {
778        request_impl(
779            self,
780            Method::GET,
781            format!("/api/servers/{server}/logs/install?lines={lines}"),
782            None::<&()>,
783            None,
784        )
785        .await
786    }
787
788    pub async fn post_servers_server_power(
789        &self,
790        server: uuid::Uuid,
791        data: &super::servers_server_power::post::RequestBody,
792    ) -> Result<super::servers_server_power::post::Response, ApiHttpError> {
793        request_impl(
794            self,
795            Method::POST,
796            format!("/api/servers/{server}/power"),
797            Some(data),
798            None,
799        )
800        .await
801    }
802
803    pub async fn post_servers_server_reinstall(
804        &self,
805        server: uuid::Uuid,
806        data: &super::servers_server_reinstall::post::RequestBody,
807    ) -> Result<super::servers_server_reinstall::post::Response, ApiHttpError> {
808        request_impl(
809            self,
810            Method::POST,
811            format!("/api/servers/{server}/reinstall"),
812            Some(data),
813            None,
814        )
815        .await
816    }
817
818    pub async fn get_servers_server_schedules_schedule(
819        &self,
820        server: uuid::Uuid,
821        schedule: uuid::Uuid,
822    ) -> Result<super::servers_server_schedules_schedule::get::Response, ApiHttpError> {
823        request_impl(
824            self,
825            Method::GET,
826            format!("/api/servers/{server}/schedules/{schedule}"),
827            None::<&()>,
828            None,
829        )
830        .await
831    }
832
833    pub async fn post_servers_server_schedules_schedule_abort(
834        &self,
835        server: uuid::Uuid,
836        schedule: uuid::Uuid,
837    ) -> Result<super::servers_server_schedules_schedule_abort::post::Response, ApiHttpError> {
838        request_impl(
839            self,
840            Method::POST,
841            format!("/api/servers/{server}/schedules/{schedule}/abort"),
842            None::<&()>,
843            None,
844        )
845        .await
846    }
847
848    pub async fn post_servers_server_schedules_schedule_trigger(
849        &self,
850        server: uuid::Uuid,
851        schedule: uuid::Uuid,
852        data: &super::servers_server_schedules_schedule_trigger::post::RequestBody,
853    ) -> Result<super::servers_server_schedules_schedule_trigger::post::Response, ApiHttpError>
854    {
855        request_impl(
856            self,
857            Method::POST,
858            format!("/api/servers/{server}/schedules/{schedule}/trigger"),
859            Some(data),
860            None,
861        )
862        .await
863    }
864
865    pub async fn post_servers_server_script(
866        &self,
867        server: uuid::Uuid,
868        data: &super::servers_server_script::post::RequestBody,
869    ) -> Result<super::servers_server_script::post::Response, ApiHttpError> {
870        request_impl(
871            self,
872            Method::POST,
873            format!("/api/servers/{server}/script"),
874            Some(data),
875            None,
876        )
877        .await
878    }
879
880    pub async fn post_servers_server_sync(
881        &self,
882        server: uuid::Uuid,
883        data: &super::servers_server_sync::post::RequestBody,
884    ) -> Result<super::servers_server_sync::post::Response, ApiHttpError> {
885        request_impl(
886            self,
887            Method::POST,
888            format!("/api/servers/{server}/sync"),
889            Some(data),
890            None,
891        )
892        .await
893    }
894
895    pub async fn delete_servers_server_transfer(
896        &self,
897        server: uuid::Uuid,
898    ) -> Result<super::servers_server_transfer::delete::Response, ApiHttpError> {
899        request_impl(
900            self,
901            Method::DELETE,
902            format!("/api/servers/{server}/transfer"),
903            None::<&()>,
904            None,
905        )
906        .await
907    }
908
909    pub async fn post_servers_server_transfer(
910        &self,
911        server: uuid::Uuid,
912        data: &super::servers_server_transfer::post::RequestBody,
913    ) -> Result<super::servers_server_transfer::post::Response, ApiHttpError> {
914        request_impl(
915            self,
916            Method::POST,
917            format!("/api/servers/{server}/transfer"),
918            Some(data),
919            None,
920        )
921        .await
922    }
923
924    pub async fn get_servers_server_utilization(
925        &self,
926        server: uuid::Uuid,
927    ) -> Result<super::servers_server_utilization::get::Response, ApiHttpError> {
928        request_impl(
929            self,
930            Method::GET,
931            format!("/api/servers/{server}/utilization"),
932            None::<&()>,
933            None,
934        )
935        .await
936    }
937
938    pub async fn get_servers_server_version(
939        &self,
940        server: uuid::Uuid,
941        game: Game,
942    ) -> Result<super::servers_server_version::get::Response, ApiHttpError> {
943        request_impl(
944            self,
945            Method::GET,
946            format!("/api/servers/{server}/version?game={game}"),
947            None::<&()>,
948            None,
949        )
950        .await
951    }
952
953    pub async fn post_servers_server_ws_broadcast(
954        &self,
955        server: uuid::Uuid,
956        data: &super::servers_server_ws_broadcast::post::RequestBody,
957    ) -> Result<super::servers_server_ws_broadcast::post::Response, ApiHttpError> {
958        request_impl(
959            self,
960            Method::POST,
961            format!("/api/servers/{server}/ws/broadcast"),
962            Some(data),
963            None,
964        )
965        .await
966    }
967
968    pub async fn post_servers_server_ws_deny(
969        &self,
970        server: uuid::Uuid,
971        data: &super::servers_server_ws_deny::post::RequestBody,
972    ) -> Result<super::servers_server_ws_deny::post::Response, ApiHttpError> {
973        request_impl(
974            self,
975            Method::POST,
976            format!("/api/servers/{server}/ws/deny"),
977            Some(data),
978            None,
979        )
980        .await
981    }
982
983    pub async fn post_servers_server_ws_permissions(
984        &self,
985        server: uuid::Uuid,
986        data: &super::servers_server_ws_permissions::post::RequestBody,
987    ) -> Result<super::servers_server_ws_permissions::post::Response, ApiHttpError> {
988        request_impl(
989            self,
990            Method::POST,
991            format!("/api/servers/{server}/ws/permissions"),
992            Some(data),
993            None,
994        )
995        .await
996    }
997
998    pub async fn get_system(&self) -> Result<super::system::get::Response, ApiHttpError> {
999        request_impl(self, Method::GET, "/api/system", None::<&()>, None).await
1000    }
1001
1002    pub async fn get_system_config(
1003        &self,
1004    ) -> Result<super::system_config::get::Response, ApiHttpError> {
1005        request_impl(self, Method::GET, "/api/system/config", None::<&()>, None).await
1006    }
1007
1008    pub async fn get_system_logs(&self) -> Result<super::system_logs::get::Response, ApiHttpError> {
1009        request_impl(self, Method::GET, "/api/system/logs", None::<&()>, None).await
1010    }
1011
1012    pub async fn get_system_logs_file(
1013        &self,
1014        file: &str,
1015        lines: u64,
1016    ) -> Result<super::system_logs_file::get::Response, ApiHttpError> {
1017        request_impl(
1018            self,
1019            Method::GET,
1020            format!("/api/system/logs/{file}?lines={lines}"),
1021            None::<&()>,
1022            None,
1023        )
1024        .await
1025    }
1026
1027    pub async fn get_system_overview(
1028        &self,
1029    ) -> Result<super::system_overview::get::Response, ApiHttpError> {
1030        request_impl(self, Method::GET, "/api/system/overview", None::<&()>, None).await
1031    }
1032
1033    pub async fn get_system_restic_prune(
1034        &self,
1035    ) -> Result<super::system_restic_prune::get::Response, ApiHttpError> {
1036        request_impl(
1037            self,
1038            Method::GET,
1039            "/api/system/restic/prune",
1040            None::<&()>,
1041            None,
1042        )
1043        .await
1044    }
1045
1046    pub async fn post_system_restic_prune(
1047        &self,
1048        data: &super::system_restic_prune::post::RequestBody,
1049    ) -> Result<super::system_restic_prune::post::Response, ApiHttpError> {
1050        request_impl(
1051            self,
1052            Method::POST,
1053            "/api/system/restic/prune",
1054            Some(data),
1055            None,
1056        )
1057        .await
1058    }
1059
1060    pub async fn get_system_restic_stats(
1061        &self,
1062    ) -> Result<super::system_restic_stats::get::Response, ApiHttpError> {
1063        request_impl(
1064            self,
1065            Method::GET,
1066            "/api/system/restic/stats",
1067            None::<&()>,
1068            None,
1069        )
1070        .await
1071    }
1072
1073    pub async fn post_system_restic_stats(
1074        &self,
1075        data: &super::system_restic_stats::post::RequestBody,
1076    ) -> Result<super::system_restic_stats::post::Response, ApiHttpError> {
1077        request_impl(
1078            self,
1079            Method::POST,
1080            "/api/system/restic/stats",
1081            Some(data),
1082            None,
1083        )
1084        .await
1085    }
1086
1087    pub async fn get_system_restic_unlock(
1088        &self,
1089    ) -> Result<super::system_restic_unlock::get::Response, ApiHttpError> {
1090        request_impl(
1091            self,
1092            Method::GET,
1093            "/api/system/restic/unlock",
1094            None::<&()>,
1095            None,
1096        )
1097        .await
1098    }
1099
1100    pub async fn post_system_restic_unlock(
1101        &self,
1102        data: &super::system_restic_unlock::post::RequestBody,
1103    ) -> Result<super::system_restic_unlock::post::Response, ApiHttpError> {
1104        request_impl(
1105            self,
1106            Method::POST,
1107            "/api/system/restic/unlock",
1108            Some(data),
1109            None,
1110        )
1111        .await
1112    }
1113
1114    pub async fn get_system_stats(
1115        &self,
1116    ) -> Result<super::system_stats::get::Response, ApiHttpError> {
1117        request_impl(self, Method::GET, "/api/system/stats", None::<&()>, None).await
1118    }
1119
1120    pub async fn post_system_upgrade(
1121        &self,
1122        data: &super::system_upgrade::post::RequestBody,
1123    ) -> Result<super::system_upgrade::post::Response, ApiHttpError> {
1124        request_impl(self, Method::POST, "/api/system/upgrade", Some(data), None).await
1125    }
1126
1127    pub async fn get_transfers(&self) -> Result<super::transfers::get::Response, ApiHttpError> {
1128        request_impl(self, Method::GET, "/api/transfers", None::<&()>, None).await
1129    }
1130
1131    pub async fn post_transfers(&self) -> Result<super::transfers::post::Response, ApiHttpError> {
1132        request_impl(self, Method::POST, "/api/transfers", None::<&()>, None).await
1133    }
1134
1135    pub async fn get_transfers_capabilities(
1136        &self,
1137    ) -> Result<super::transfers_capabilities::get::Response, ApiHttpError> {
1138        request_impl(
1139            self,
1140            Method::GET,
1141            "/api/transfers/capabilities",
1142            None::<&()>,
1143            None,
1144        )
1145        .await
1146    }
1147
1148    pub async fn post_transfers_files(
1149        &self,
1150    ) -> Result<super::transfers_files::post::Response, ApiHttpError> {
1151        request_impl(
1152            self,
1153            Method::POST,
1154            "/api/transfers/files",
1155            None::<&()>,
1156            None,
1157        )
1158        .await
1159    }
1160
1161    pub async fn get_transfers_query(
1162        &self,
1163    ) -> Result<super::transfers_query::get::Response, ApiHttpError> {
1164        request_impl(self, Method::GET, "/api/transfers/query", None::<&()>, None).await
1165    }
1166
1167    pub async fn delete_transfers_server(
1168        &self,
1169        server: uuid::Uuid,
1170    ) -> Result<super::transfers_server::delete::Response, ApiHttpError> {
1171        request_impl(
1172            self,
1173            Method::DELETE,
1174            format!("/api/transfers/{server}"),
1175            None::<&()>,
1176            None,
1177        )
1178        .await
1179    }
1180
1181    pub async fn post_update(
1182        &self,
1183        data: &super::update::post::RequestBody,
1184    ) -> Result<super::update::post::Response, ApiHttpError> {
1185        request_impl(self, Method::POST, "/api/update", Some(data), None).await
1186    }
1187}
wings_api/client.rs

wings_api/
client.rs
