wings_api/
lib.rs

1//! The Calagopus Panel Wings API library.
2//!
3//! Used for communicating with the Wings daemon. This library contains
4//! auto-generated code from the OpenAPI specification as well as
5//! some utilities for working with the Wings API. In 99% of cases you will
6//! want to use the [crate::client::WingsClient] struct to interact with the API.
7
8use indexmap::IndexMap;
9use serde::{Deserialize, Serialize};
10use utoipa::ToSchema;
11
12pub mod client;
13mod extra;
14
15use client::AsyncResponseReader;
16pub use extra::*;
17
18nestify::nest! {
19    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ApiError {
20        #[schema(inline)]
21        pub error: compact_str::CompactString,
22    }
23}
24
25#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
26pub enum AppContainerType {
27    #[serde(rename = "official")]
28    Official,
29    #[serde(rename = "unknown")]
30    Unknown,
31    #[serde(rename = "none")]
32    None,
33}
34
35#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
36pub enum ArchiveFormat {
37    #[serde(rename = "tar")]
38    Tar,
39    #[serde(rename = "tar_gz")]
40    TarGz,
41    #[serde(rename = "tar_xz")]
42    TarXz,
43    #[serde(rename = "tar_lzip")]
44    TarLzip,
45    #[serde(rename = "tar_bz2")]
46    TarBz2,
47    #[serde(rename = "tar_lz4")]
48    TarLz4,
49    #[serde(rename = "tar_zstd")]
50    TarZstd,
51    #[serde(rename = "zip")]
52    Zip,
53    #[serde(rename = "seven_zip")]
54    SevenZip,
55}
56
57#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
58pub enum BackupAdapter {
59    #[serde(rename = "wings")]
60    Wings,
61    #[serde(rename = "s3")]
62    S3,
63    #[serde(rename = "ddup-bak")]
64    DdupBak,
65    #[serde(rename = "btrfs")]
66    Btrfs,
67    #[serde(rename = "zfs")]
68    Zfs,
69    #[serde(rename = "restic")]
70    Restic,
71}
72
73#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
74pub enum CompressionLevel {
75    #[serde(rename = "best_speed")]
76    BestSpeed,
77    #[serde(rename = "good_speed")]
78    GoodSpeed,
79    #[serde(rename = "good_compression")]
80    GoodCompression,
81    #[serde(rename = "best_compression")]
82    BestCompression,
83}
84
85nestify::nest! {
86    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct DirectoryEntry {
87        #[schema(inline)]
88        pub name: compact_str::CompactString,
89        #[schema(inline)]
90        pub mode: compact_str::CompactString,
91        #[schema(inline)]
92        pub mode_bits: compact_str::CompactString,
93        #[schema(inline)]
94        pub size: u64,
95        #[schema(inline)]
96        pub size_physical: u64,
97        #[schema(inline)]
98        pub editable: bool,
99        #[schema(inline)]
100        pub inner_editable: bool,
101        #[schema(inline)]
102        pub directory: bool,
103        #[schema(inline)]
104        pub file: bool,
105        #[schema(inline)]
106        pub symlink: bool,
107        #[schema(inline)]
108        pub mime: compact_str::CompactString,
109        #[schema(inline)]
110        pub created: chrono::DateTime<chrono::Local>,
111        #[schema(inline)]
112        pub modified: chrono::DateTime<chrono::Local>,
113    }
114}
115
116#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
117pub enum DiskLimiterMode {
118    #[serde(rename = "none")]
119    None,
120    #[serde(rename = "btrfs_subvolume")]
121    BtrfsSubvolume,
122    #[serde(rename = "zfs_dataset")]
123    ZfsDataset,
124    #[serde(rename = "xfs_quota")]
125    XfsQuota,
126    #[serde(rename = "fuse_quota")]
127    FuseQuota,
128}
129
130nestify::nest! {
131    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Download {
132        #[schema(inline)]
133        pub identifier: uuid::Uuid,
134        #[schema(inline)]
135        pub destination: compact_str::CompactString,
136        #[schema(inline)]
137        pub progress: u64,
138        #[schema(inline)]
139        pub total: u64,
140    }
141}
142
143nestify::nest! {
144    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct InstallationScript {
145        #[schema(inline)]
146        pub container_image: compact_str::CompactString,
147        #[schema(inline)]
148        pub entrypoint: compact_str::CompactString,
149        #[schema(inline)]
150        pub script: compact_str::CompactString,
151        #[schema(inline)]
152        pub environment: IndexMap<compact_str::CompactString, serde_json::Value>,
153    }
154}
155
156pub type MiB = u64;
157
158nestify::nest! {
159    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Mount {
160        #[schema(inline)]
161        pub target: compact_str::CompactString,
162        #[schema(inline)]
163        pub source: compact_str::CompactString,
164        #[schema(inline)]
165        pub read_only: bool,
166    }
167}
168
169nestify::nest! {
170    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ResourceUsage {
171        #[schema(inline)]
172        pub memory_bytes: u64,
173        #[schema(inline)]
174        pub memory_limit_bytes: u64,
175        #[schema(inline)]
176        pub disk_bytes: u64,
177        #[schema(inline)]
178        pub state: ServerState,
179        #[schema(inline)]
180        pub network: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ResourceUsageNetwork {
181            #[schema(inline)]
182            pub rx_bytes: u64,
183            #[schema(inline)]
184            pub tx_bytes: u64,
185        },
186
187        #[schema(inline)]
188        pub cpu_absolute: f64,
189        #[schema(inline)]
190        pub uptime: u64,
191    }
192}
193
194nestify::nest! {
195    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Schedule {
196        #[schema(inline)]
197        pub uuid: uuid::Uuid,
198        #[schema(inline)]
199        pub triggers: serde_json::Value,
200        #[schema(inline)]
201        pub condition: serde_json::Value,
202        #[schema(inline)]
203        pub actions: Vec<serde_json::Value>,
204    }
205}
206
207nestify::nest! {
208    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ScheduleStatus {
209        #[schema(inline)]
210        pub running: bool,
211        #[schema(inline)]
212        pub errors: IndexMap<uuid::Uuid, compact_str::CompactString>,
213        #[schema(inline)]
214        pub step: Option<uuid::Uuid>,
215    }
216}
217
218nestify::nest! {
219    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Server {
220        #[schema(inline)]
221        pub state: ServerState,
222        #[schema(inline)]
223        pub is_suspended: bool,
224        #[schema(inline)]
225        pub utilization: ResourceUsage,
226        #[schema(inline)]
227        pub configuration: ServerConfiguration,
228    }
229}
230
231#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
232pub enum ServerAutoStartBehavior {
233    #[serde(rename = "always")]
234    Always,
235    #[serde(rename = "unless_stopped")]
236    UnlessStopped,
237    #[serde(rename = "never")]
238    Never,
239}
240
241nestify::nest! {
242    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfiguration {
243        #[schema(inline)]
244        pub uuid: uuid::Uuid,
245        #[schema(inline)]
246        pub start_on_completion: Option<bool>,
247        #[schema(inline)]
248        pub meta: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationMeta {
249            #[schema(inline)]
250            pub name: compact_str::CompactString,
251            #[schema(inline)]
252            pub description: compact_str::CompactString,
253        },
254
255        #[schema(inline)]
256        pub suspended: bool,
257        #[schema(inline)]
258        pub invocation: compact_str::CompactString,
259        #[schema(inline)]
260        pub skip_egg_scripts: bool,
261        #[schema(inline)]
262        pub entrypoint: Option<Vec<compact_str::CompactString>>,
263        #[schema(inline)]
264        pub environment: IndexMap<compact_str::CompactString, serde_json::Value>,
265        #[schema(inline)]
266        pub labels: IndexMap<compact_str::CompactString, compact_str::CompactString>,
267        #[schema(inline)]
268        pub backups: Vec<uuid::Uuid>,
269        #[schema(inline)]
270        pub schedules: Vec<Schedule>,
271        #[schema(inline)]
272        pub allocations: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationAllocations {
273            #[schema(inline)]
274            pub force_outgoing_ip: bool,
275            #[schema(inline)]
276            pub default: Option<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationAllocationsDefault {
277                #[schema(inline)]
278                pub ip: compact_str::CompactString,
279                #[schema(inline)]
280                pub port: u32,
281            }>,
282            #[schema(inline)]
283            pub mappings: IndexMap<compact_str::CompactString, Vec<u32>>,
284        },
285
286        #[schema(inline)]
287        pub build: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationBuild {
288            #[schema(inline)]
289            pub memory_limit: i64,
290            #[schema(inline)]
291            pub overhead_memory: i64,
292            #[schema(inline)]
293            pub swap: i64,
294            #[schema(inline)]
295            pub io_weight: Option<u32>,
296            #[schema(inline)]
297            pub cpu_limit: i64,
298            #[schema(inline)]
299            pub disk_space: u64,
300            #[schema(inline)]
301            pub threads: Option<compact_str::CompactString>,
302            #[schema(inline)]
303            pub oom_disabled: bool,
304        },
305
306        #[schema(inline)]
307        pub mounts: Vec<Mount>,
308        #[schema(inline)]
309        pub egg: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationEgg {
310            #[schema(inline)]
311            pub id: uuid::Uuid,
312            #[schema(inline)]
313            pub file_denylist: Vec<compact_str::CompactString>,
314        },
315
316        #[schema(inline)]
317        pub container: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationContainer {
318            #[schema(inline)]
319            pub image: compact_str::CompactString,
320            #[schema(inline)]
321            pub timezone: Option<compact_str::CompactString>,
322            #[schema(inline)]
323            pub hugepages_passthrough_enabled: bool,
324            #[schema(inline)]
325            pub kvm_passthrough_enabled: bool,
326            #[schema(inline)]
327            pub seccomp: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationContainerSeccomp {
328                #[schema(inline)]
329                pub remove_allowed: Vec<compact_str::CompactString>,
330            },
331
332        },
333
334        #[schema(inline)]
335        pub auto_kill: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationAutoKill {
336            #[schema(inline)]
337            pub enabled: bool,
338            #[schema(inline)]
339            pub seconds: u64,
340        },
341
342        #[schema(inline)]
343        pub auto_start_behavior: ServerAutoStartBehavior,
344    }
345}
346
347#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
348pub enum ServerPowerAction {
349    #[serde(rename = "start")]
350    Start,
351    #[serde(rename = "stop")]
352    Stop,
353    #[serde(rename = "restart")]
354    Restart,
355    #[serde(rename = "kill")]
356    Kill,
357}
358
359#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
360pub enum ServerState {
361    #[serde(rename = "offline")]
362    Offline,
363    #[serde(rename = "starting")]
364    Starting,
365    #[serde(rename = "stopping")]
366    Stopping,
367    #[serde(rename = "running")]
368    Running,
369}
370
371#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
372pub enum SystemBackupsDdupBakCompressionFormat {
373    #[serde(rename = "none")]
374    None,
375    #[serde(rename = "deflate")]
376    Deflate,
377    #[serde(rename = "gzip")]
378    Gzip,
379    #[serde(rename = "brotli")]
380    Brotli,
381}
382
383nestify::nest! {
384    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct SystemStats {
385        #[schema(inline)]
386        pub cpu: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct SystemStatsCpu {
387            #[schema(inline)]
388            pub used: f64,
389            #[schema(inline)]
390            pub threads: u64,
391            #[schema(inline)]
392            pub model: compact_str::CompactString,
393        },
394
395        #[schema(inline)]
396        pub network: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct SystemStatsNetwork {
397            #[schema(inline)]
398            pub received: u64,
399            #[schema(inline)]
400            pub receiving_rate: f64,
401            #[schema(inline)]
402            pub sent: u64,
403            #[schema(inline)]
404            pub sending_rate: f64,
405        },
406
407        #[schema(inline)]
408        pub memory: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct SystemStatsMemory {
409            #[schema(inline)]
410            pub used: u64,
411            #[schema(inline)]
412            pub used_process: u64,
413            #[schema(inline)]
414            pub total: u64,
415        },
416
417        #[schema(inline)]
418        pub disk: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct SystemStatsDisk {
419            #[schema(inline)]
420            pub used: u64,
421            #[schema(inline)]
422            pub total: u64,
423            #[schema(inline)]
424            pub read: u64,
425            #[schema(inline)]
426            pub reading_rate: f64,
427            #[schema(inline)]
428            pub written: u64,
429            #[schema(inline)]
430            pub writing_rate: f64,
431        },
432
433    }
434}
435
436#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
437pub enum TransferArchiveFormat {
438    #[serde(rename = "tar")]
439    Tar,
440    #[serde(rename = "tar_gz")]
441    TarGz,
442    #[serde(rename = "tar_xz")]
443    TarXz,
444    #[serde(rename = "tar_lzip")]
445    TarLzip,
446    #[serde(rename = "tar_bz2")]
447    TarBz2,
448    #[serde(rename = "tar_lz4")]
449    TarLz4,
450    #[serde(rename = "tar_zstd")]
451    TarZstd,
452}
453
454nestify::nest! {
455    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct TransferProgress {
456        #[schema(inline)]
457        pub archive_progress: u64,
458        #[schema(inline)]
459        pub network_progress: u64,
460        #[schema(inline)]
461        pub total: u64,
462    }
463}
464
465#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
466pub enum WebsocketEvent {
467    #[serde(rename = "auth success")]
468    AuthSuccess,
469    #[serde(rename = "token expiring")]
470    TokenExpiring,
471    #[serde(rename = "token expired")]
472    TokenExpired,
473    #[serde(rename = "auth")]
474    Auth,
475    #[serde(rename = "configure socket")]
476    ConfigureSocket,
477    #[serde(rename = "set state")]
478    SetState,
479    #[serde(rename = "send logs")]
480    SendLogs,
481    #[serde(rename = "send command")]
482    SendCommand,
483    #[serde(rename = "send stats")]
484    SendStats,
485    #[serde(rename = "send status")]
486    SendStatus,
487    #[serde(rename = "daemon error")]
488    DaemonError,
489    #[serde(rename = "jwt error")]
490    JwtError,
491    #[serde(rename = "ping")]
492    Ping,
493    #[serde(rename = "pong")]
494    Pong,
495    #[serde(rename = "stats")]
496    Stats,
497    #[serde(rename = "status")]
498    Status,
499    #[serde(rename = "custom event")]
500    CustomEvent,
501    #[serde(rename = "console output")]
502    ConsoleOutput,
503    #[serde(rename = "install output")]
504    InstallOutput,
505    #[serde(rename = "image pull progress")]
506    ImagePullProgress,
507    #[serde(rename = "image pull completed")]
508    ImagePullCompleted,
509    #[serde(rename = "install started")]
510    InstallStarted,
511    #[serde(rename = "install completed")]
512    InstallCompleted,
513    #[serde(rename = "daemon message")]
514    DaemonMessage,
515    #[serde(rename = "backup started")]
516    BackupStarted,
517    #[serde(rename = "backup progress")]
518    BackupProgress,
519    #[serde(rename = "backup completed")]
520    BackupCompleted,
521    #[serde(rename = "backup restore started")]
522    BackupRestoreStarted,
523    #[serde(rename = "backup restore progress")]
524    BackupRestoreProgress,
525    #[serde(rename = "backup restore completed")]
526    BackupRestoreCompleted,
527    #[serde(rename = "transfer logs")]
528    TransferLogs,
529    #[serde(rename = "transfer status")]
530    TransferStatus,
531    #[serde(rename = "transfer progress")]
532    TransferProgress,
533    #[serde(rename = "schedule started")]
534    ScheduleStarted,
535    #[serde(rename = "schedule step status")]
536    ScheduleStepStatus,
537    #[serde(rename = "schedule step error")]
538    ScheduleStepError,
539    #[serde(rename = "schedule completed")]
540    ScheduleCompleted,
541    #[serde(rename = "operation progress")]
542    OperationProgress,
543    #[serde(rename = "operation error")]
544    OperationError,
545    #[serde(rename = "operation completed")]
546    OperationCompleted,
547}
548
549nestify::nest! {
550    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct WebsocketMessage {
551        #[schema(inline)]
552        pub event: WebsocketEvent,
553        #[schema(inline)]
554        pub args: Vec<compact_str::CompactString>,
555    }
556}
557
558pub mod backups_backup {
559    use super::*;
560
561    pub mod delete {
562        use super::*;
563
564        nestify::nest! {
565            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
566                #[schema(inline)]
567                pub adapter: BackupAdapter,
568            }
569        }
570
571        nestify::nest! {
572            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
573            }
574        }
575
576        pub type Response404 = ApiError;
577
578        pub type Response = Response202;
579    }
580}
581pub mod deauthorize_user {
582    use super::*;
583
584    pub mod post {
585        use super::*;
586
587        nestify::nest! {
588            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
589                #[schema(inline)]
590                pub servers: Vec<uuid::Uuid>,
591                #[schema(inline)]
592                pub user: uuid::Uuid,
593            }
594        }
595
596        nestify::nest! {
597            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
598            }
599        }
600
601        nestify::nest! {
602            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response409 {
603                #[schema(inline)]
604                pub error: compact_str::CompactString,
605            }
606        }
607
608        pub type Response = Response200;
609    }
610}
611pub mod servers {
612    use super::*;
613
614    pub mod get {
615        use super::*;
616
617        pub type Response200 = Vec<Server>;
618
619        pub type Response = Response200;
620    }
621
622    pub mod post {
623        use super::*;
624
625        nestify::nest! {
626            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
627                #[schema(inline)]
628                pub uuid: uuid::Uuid,
629                #[schema(inline)]
630                pub start_on_completion: bool,
631                #[schema(inline)]
632                pub skip_scripts: bool,
633            }
634        }
635
636        nestify::nest! {
637            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
638            }
639        }
640
641        pub type Response409 = ApiError;
642
643        pub type Response = Response200;
644    }
645}
646pub mod servers_power {
647    use super::*;
648
649    pub mod post {
650        use super::*;
651
652        nestify::nest! {
653            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
654                #[schema(inline)]
655                pub servers: Vec<uuid::Uuid>,
656                #[schema(inline)]
657                pub action: ServerPowerAction,
658                #[schema(inline)]
659                pub wait_seconds: Option<u64>,
660            }
661        }
662
663        nestify::nest! {
664            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
665                #[schema(inline)]
666                pub affected: u64,
667            }
668        }
669
670        pub type Response = Response202;
671    }
672}
673pub mod servers_utilization {
674    use super::*;
675
676    pub mod get {
677        use super::*;
678
679        type Response200 = IndexMap<uuid::Uuid, ResourceUsage>;
680        pub type Response404 = ApiError;
681
682        pub type Response = Response200;
683    }
684}
685pub mod servers_server {
686    use super::*;
687
688    pub mod get {
689        use super::*;
690
691        pub type Response200 = Server;
692
693        pub type Response = Response200;
694    }
695
696    pub mod delete {
697        use super::*;
698
699        nestify::nest! {
700            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
701            }
702        }
703
704        pub type Response = Response200;
705    }
706}
707pub mod servers_server_backup {
708    use super::*;
709
710    pub mod post {
711        use super::*;
712
713        nestify::nest! {
714            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
715                #[schema(inline)]
716                pub adapter: BackupAdapter,
717                #[schema(inline)]
718                pub uuid: uuid::Uuid,
719                #[schema(inline)]
720                pub ignore: compact_str::CompactString,
721            }
722        }
723
724        nestify::nest! {
725            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
726            }
727        }
728
729        pub type Response409 = ApiError;
730
731        pub type Response = Response202;
732    }
733}
734pub mod servers_server_backup_backup {
735    use super::*;
736
737    pub mod delete {
738        use super::*;
739
740        nestify::nest! {
741            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
742            }
743        }
744
745        pub type Response404 = ApiError;
746
747        pub type Response = Response202;
748    }
749}
750pub mod servers_server_backup_backup_restore {
751    use super::*;
752
753    pub mod post {
754        use super::*;
755
756        nestify::nest! {
757            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
758                #[schema(inline)]
759                pub adapter: BackupAdapter,
760                #[schema(inline)]
761                pub truncate_directory: bool,
762                #[schema(inline)]
763                pub download_url: Option<compact_str::CompactString>,
764            }
765        }
766
767        nestify::nest! {
768            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
769            }
770        }
771
772        pub type Response404 = ApiError;
773
774        pub type Response = Response202;
775    }
776}
777pub mod servers_server_commands {
778    use super::*;
779
780    pub mod post {
781        use super::*;
782
783        nestify::nest! {
784            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
785                #[schema(inline)]
786                pub commands: Vec<compact_str::CompactString>,
787            }
788        }
789
790        nestify::nest! {
791            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
792            }
793        }
794
795        pub type Response417 = ApiError;
796
797        pub type Response = Response200;
798    }
799}
800pub mod servers_server_files_chmod {
801    use super::*;
802
803    pub mod post {
804        use super::*;
805
806        nestify::nest! {
807            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
808                #[schema(inline)]
809                pub root: compact_str::CompactString,
810                #[schema(inline)]
811                pub files: Vec<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodyFiles {
812                    #[schema(inline)]
813                    pub file: compact_str::CompactString,
814                    #[schema(inline)]
815                    pub mode: compact_str::CompactString,
816                }>,
817            }
818        }
819
820        nestify::nest! {
821            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
822                #[schema(inline)]
823                pub updated: u64,
824            }
825        }
826
827        pub type Response404 = ApiError;
828
829        pub type Response417 = ApiError;
830
831        pub type Response = Response200;
832    }
833}
834pub mod servers_server_files_compress {
835    use super::*;
836
837    pub mod post {
838        use super::*;
839
840        nestify::nest! {
841            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
842                #[schema(inline)]
843                pub format: ArchiveFormat,
844                #[schema(inline)]
845                pub name: Option<compact_str::CompactString>,
846                #[schema(inline)]
847                pub root: compact_str::CompactString,
848                #[schema(inline)]
849                pub files: Vec<compact_str::CompactString>,
850                #[schema(inline)]
851                pub foreground: bool,
852            }
853        }
854
855        pub type Response200 = DirectoryEntry;
856
857        nestify::nest! {
858            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
859                #[schema(inline)]
860                pub identifier: uuid::Uuid,
861            }
862        }
863
864        pub type Response404 = ApiError;
865
866        pub type Response417 = ApiError;
867
868        #[derive(Deserialize)]
869        #[serde(untagged)]
870        pub enum Response {
871            Ok(Response200),
872            Accepted(Response202),
873        }
874    }
875}
876pub mod servers_server_files_contents {
877    use super::*;
878
879    pub mod get {
880        use super::*;
881
882        pub type Response200 = AsyncResponseReader;
883
884        pub type Response404 = ApiError;
885
886        pub type Response413 = ApiError;
887
888        pub type Response417 = ApiError;
889
890        pub type Response = Response200;
891    }
892}
893pub mod servers_server_files_copy {
894    use super::*;
895
896    pub mod post {
897        use super::*;
898
899        nestify::nest! {
900            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
901                #[schema(inline)]
902                pub path: compact_str::CompactString,
903                #[schema(inline)]
904                pub name: Option<compact_str::CompactString>,
905                #[schema(inline)]
906                pub foreground: bool,
907            }
908        }
909
910        pub type Response200 = DirectoryEntry;
911
912        nestify::nest! {
913            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
914                #[schema(inline)]
915                pub identifier: uuid::Uuid,
916            }
917        }
918
919        pub type Response404 = ApiError;
920
921        pub type Response417 = ApiError;
922
923        #[derive(Deserialize)]
924        #[serde(untagged)]
925        pub enum Response {
926            Ok(Response200),
927            Accepted(Response202),
928        }
929    }
930}
931pub mod servers_server_files_copy_many {
932    use super::*;
933
934    pub mod post {
935        use super::*;
936
937        nestify::nest! {
938            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
939                #[schema(inline)]
940                pub root: compact_str::CompactString,
941                #[schema(inline)]
942                pub files: Vec<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodyFiles {
943                    #[schema(inline)]
944                    pub from: compact_str::CompactString,
945                    #[schema(inline)]
946                    pub to: compact_str::CompactString,
947                }>,
948                #[schema(inline)]
949                pub foreground: bool,
950            }
951        }
952
953        nestify::nest! {
954            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
955                #[schema(inline)]
956                pub copied: u64,
957            }
958        }
959
960        nestify::nest! {
961            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
962                #[schema(inline)]
963                pub identifier: uuid::Uuid,
964            }
965        }
966
967        pub type Response404 = ApiError;
968
969        pub type Response417 = ApiError;
970
971        #[derive(Deserialize)]
972        #[serde(untagged)]
973        pub enum Response {
974            Ok(Response200),
975            Accepted(Response202),
976        }
977    }
978}
979pub mod servers_server_files_copy_remote {
980    use super::*;
981
982    pub mod post {
983        use super::*;
984
985        nestify::nest! {
986            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
987                #[schema(inline)]
988                pub url: compact_str::CompactString,
989                #[schema(inline)]
990                pub token: compact_str::CompactString,
991                #[schema(inline)]
992                pub archive_format: TransferArchiveFormat,
993                #[schema(inline)]
994                pub compression_level: Option<CompressionLevel>,
995                #[schema(inline)]
996                pub root: compact_str::CompactString,
997                #[schema(inline)]
998                pub files: Vec<compact_str::CompactString>,
999                #[schema(inline)]
1000                pub destination_server: uuid::Uuid,
1001                #[schema(inline)]
1002                pub destination_path: compact_str::CompactString,
1003                #[schema(inline)]
1004                pub foreground: bool,
1005            }
1006        }
1007
1008        nestify::nest! {
1009            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1010            }
1011        }
1012
1013        nestify::nest! {
1014            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1015                #[schema(inline)]
1016                pub identifier: uuid::Uuid,
1017            }
1018        }
1019
1020        pub type Response404 = ApiError;
1021
1022        pub type Response417 = ApiError;
1023
1024        #[derive(Deserialize)]
1025        #[serde(untagged)]
1026        pub enum Response {
1027            Ok(Response200),
1028            Accepted(Response202),
1029        }
1030    }
1031}
1032pub mod servers_server_files_create_directory {
1033    use super::*;
1034
1035    pub mod post {
1036        use super::*;
1037
1038        nestify::nest! {
1039            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1040                #[schema(inline)]
1041                pub root: compact_str::CompactString,
1042                #[schema(inline)]
1043                pub name: compact_str::CompactString,
1044            }
1045        }
1046
1047        nestify::nest! {
1048            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1049            }
1050        }
1051
1052        pub type Response404 = ApiError;
1053
1054        pub type Response417 = ApiError;
1055
1056        pub type Response = Response200;
1057    }
1058}
1059pub mod servers_server_files_decompress {
1060    use super::*;
1061
1062    pub mod post {
1063        use super::*;
1064
1065        nestify::nest! {
1066            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1067                #[schema(inline)]
1068                pub root: compact_str::CompactString,
1069                #[schema(inline)]
1070                pub file: compact_str::CompactString,
1071                #[schema(inline)]
1072                pub foreground: bool,
1073            }
1074        }
1075
1076        nestify::nest! {
1077            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1078            }
1079        }
1080
1081        nestify::nest! {
1082            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1083                #[schema(inline)]
1084                pub identifier: uuid::Uuid,
1085            }
1086        }
1087
1088        pub type Response404 = ApiError;
1089
1090        pub type Response417 = ApiError;
1091
1092        #[derive(Deserialize)]
1093        #[serde(untagged)]
1094        pub enum Response {
1095            Ok(Response200),
1096            Accepted(Response202),
1097        }
1098    }
1099}
1100pub mod servers_server_files_delete {
1101    use super::*;
1102
1103    pub mod post {
1104        use super::*;
1105
1106        nestify::nest! {
1107            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1108                #[schema(inline)]
1109                pub root: compact_str::CompactString,
1110                #[schema(inline)]
1111                pub files: Vec<compact_str::CompactString>,
1112            }
1113        }
1114
1115        nestify::nest! {
1116            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1117                #[schema(inline)]
1118                pub deleted: u64,
1119            }
1120        }
1121
1122        pub type Response404 = ApiError;
1123
1124        pub type Response417 = ApiError;
1125
1126        pub type Response = Response200;
1127    }
1128}
1129pub mod servers_server_files_fingerprints {
1130    use super::*;
1131
1132    pub mod get {
1133        use super::*;
1134
1135        nestify::nest! {
1136            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1137                #[schema(inline)]
1138                pub fingerprints: IndexMap<compact_str::CompactString, compact_str::CompactString>,
1139            }
1140        }
1141
1142        pub type Response = Response200;
1143    }
1144}
1145pub mod servers_server_files_list {
1146    use super::*;
1147
1148    pub mod get {
1149        use super::*;
1150
1151        nestify::nest! {
1152            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1153                #[schema(inline)]
1154                pub total: u64,
1155                #[schema(inline)]
1156                pub filesystem_writable: bool,
1157                #[schema(inline)]
1158                pub filesystem_fast: bool,
1159                #[schema(inline)]
1160                pub entries: Vec<DirectoryEntry>,
1161            }
1162        }
1163
1164        pub type Response404 = ApiError;
1165
1166        pub type Response417 = ApiError;
1167
1168        pub type Response = Response200;
1169    }
1170}
1171pub mod servers_server_files_list_directory {
1172    use super::*;
1173
1174    pub mod get {
1175        use super::*;
1176
1177        pub type Response200 = Vec<DirectoryEntry>;
1178
1179        pub type Response404 = ApiError;
1180
1181        pub type Response417 = ApiError;
1182
1183        pub type Response = Response200;
1184    }
1185}
1186pub mod servers_server_files_operations_operation {
1187    use super::*;
1188
1189    pub mod delete {
1190        use super::*;
1191
1192        nestify::nest! {
1193            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1194            }
1195        }
1196
1197        pub type Response404 = ApiError;
1198
1199        pub type Response = Response200;
1200    }
1201}
1202pub mod servers_server_files_pull {
1203    use super::*;
1204
1205    pub mod get {
1206        use super::*;
1207
1208        nestify::nest! {
1209            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1210                #[schema(inline)]
1211                pub downloads: Vec<Download>,
1212            }
1213        }
1214
1215        pub type Response = Response200;
1216    }
1217
1218    pub mod post {
1219        use super::*;
1220
1221        nestify::nest! {
1222            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1223                #[schema(inline)]
1224                pub root: compact_str::CompactString,
1225                #[schema(inline)]
1226                pub url: compact_str::CompactString,
1227                #[schema(inline)]
1228                pub file_name: Option<compact_str::CompactString>,
1229                #[schema(inline)]
1230                pub use_header: bool,
1231                #[schema(inline)]
1232                pub foreground: bool,
1233            }
1234        }
1235
1236        nestify::nest! {
1237            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1238            }
1239        }
1240
1241        nestify::nest! {
1242            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1243                #[schema(inline)]
1244                pub identifier: uuid::Uuid,
1245            }
1246        }
1247
1248        pub type Response417 = ApiError;
1249
1250        #[derive(Deserialize)]
1251        #[serde(untagged)]
1252        pub enum Response {
1253            Ok(Response200),
1254            Accepted(Response202),
1255        }
1256    }
1257}
1258pub mod servers_server_files_pull_query {
1259    use super::*;
1260
1261    pub mod post {
1262        use super::*;
1263
1264        nestify::nest! {
1265            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1266                #[schema(inline)]
1267                pub url: compact_str::CompactString,
1268            }
1269        }
1270
1271        nestify::nest! {
1272            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1273                #[schema(inline)]
1274                pub file_name: Option<compact_str::CompactString>,
1275                #[schema(inline)]
1276                pub file_size: Option<u64>,
1277                #[schema(inline)]
1278                pub final_url: compact_str::CompactString,
1279                #[schema(inline)]
1280                pub headers: IndexMap<compact_str::CompactString, compact_str::CompactString>,
1281            }
1282        }
1283
1284        pub type Response417 = ApiError;
1285
1286        pub type Response = Response200;
1287    }
1288}
1289pub mod servers_server_files_pull_pull {
1290    use super::*;
1291
1292    pub mod delete {
1293        use super::*;
1294
1295        nestify::nest! {
1296            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1297            }
1298        }
1299
1300        pub type Response404 = ApiError;
1301
1302        pub type Response = Response200;
1303    }
1304}
1305pub mod servers_server_files_rename {
1306    use super::*;
1307
1308    pub mod put {
1309        use super::*;
1310
1311        nestify::nest! {
1312            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1313                #[schema(inline)]
1314                pub root: compact_str::CompactString,
1315                #[schema(inline)]
1316                pub files: Vec<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodyFiles {
1317                    #[schema(inline)]
1318                    pub from: compact_str::CompactString,
1319                    #[schema(inline)]
1320                    pub to: compact_str::CompactString,
1321                }>,
1322            }
1323        }
1324
1325        nestify::nest! {
1326            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1327                #[schema(inline)]
1328                pub renamed: u64,
1329            }
1330        }
1331
1332        pub type Response404 = ApiError;
1333
1334        pub type Response = Response200;
1335    }
1336}
1337pub mod servers_server_files_search {
1338    use super::*;
1339
1340    pub mod post {
1341        use super::*;
1342
1343        nestify::nest! {
1344            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1345                #[schema(inline)]
1346                pub root: compact_str::CompactString,
1347                #[schema(inline)]
1348                pub path_filter: Option<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodyPathFilter {
1349                    #[schema(inline)]
1350                    pub include: Vec<compact_str::CompactString>,
1351                    #[schema(inline)]
1352                    pub exclude: Vec<compact_str::CompactString>,
1353                    #[schema(inline)]
1354                    pub case_insensitive: bool,
1355                }>,
1356                #[schema(inline)]
1357                pub size_filter: Option<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodySizeFilter {
1358                    #[schema(inline)]
1359                    pub min: u64,
1360                    #[schema(inline)]
1361                    pub max: u64,
1362                }>,
1363                #[schema(inline)]
1364                pub content_filter: Option<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodyContentFilter {
1365                    #[schema(inline)]
1366                    pub query: compact_str::CompactString,
1367                    #[schema(inline)]
1368                    pub max_search_size: u64,
1369                    #[schema(inline)]
1370                    pub include_unmatched: bool,
1371                    #[schema(inline)]
1372                    pub case_insensitive: bool,
1373                }>,
1374                #[schema(inline)]
1375                pub per_page: u64,
1376            }
1377        }
1378
1379        nestify::nest! {
1380            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1381                #[schema(inline)]
1382                pub results: Vec<DirectoryEntry>,
1383            }
1384        }
1385
1386        pub type Response404 = ApiError;
1387
1388        pub type Response = Response200;
1389    }
1390}
1391pub mod servers_server_files_write {
1392    use super::*;
1393
1394    pub mod post {
1395        use super::*;
1396
1397        pub type RequestBody = compact_str::CompactString;
1398
1399        nestify::nest! {
1400            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1401            }
1402        }
1403
1404        pub type Response404 = ApiError;
1405
1406        pub type Response417 = ApiError;
1407
1408        pub type Response = Response200;
1409    }
1410}
1411pub mod servers_server_install_abort {
1412    use super::*;
1413
1414    pub mod post {
1415        use super::*;
1416
1417        nestify::nest! {
1418            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1419            }
1420        }
1421
1422        pub type Response409 = ApiError;
1423
1424        pub type Response = Response202;
1425    }
1426}
1427pub mod servers_server_logs {
1428    use super::*;
1429
1430    pub mod get {
1431        use super::*;
1432
1433        pub type Response200 = AsyncResponseReader;
1434
1435        pub type Response = Response200;
1436    }
1437}
1438pub mod servers_server_logs_install {
1439    use super::*;
1440
1441    pub mod get {
1442        use super::*;
1443
1444        pub type Response200 = AsyncResponseReader;
1445
1446        pub type Response404 = ApiError;
1447
1448        pub type Response = Response200;
1449    }
1450}
1451pub mod servers_server_power {
1452    use super::*;
1453
1454    pub mod post {
1455        use super::*;
1456
1457        nestify::nest! {
1458            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1459                #[schema(inline)]
1460                pub action: ServerPowerAction,
1461                #[schema(inline)]
1462                pub wait_seconds: Option<u64>,
1463            }
1464        }
1465
1466        nestify::nest! {
1467            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1468            }
1469        }
1470
1471        pub type Response = Response202;
1472    }
1473}
1474pub mod servers_server_reinstall {
1475    use super::*;
1476
1477    pub mod post {
1478        use super::*;
1479
1480        nestify::nest! {
1481            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1482                #[schema(inline)]
1483                pub truncate_directory: bool,
1484                #[schema(inline)]
1485                pub installation_script: Option<InstallationScript>,
1486            }
1487        }
1488
1489        nestify::nest! {
1490            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1491            }
1492        }
1493
1494        pub type Response409 = ApiError;
1495
1496        pub type Response = Response202;
1497    }
1498}
1499pub mod servers_server_schedules_schedule {
1500    use super::*;
1501
1502    pub mod get {
1503        use super::*;
1504
1505        nestify::nest! {
1506            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1507                #[schema(inline)]
1508                pub status: ScheduleStatus,
1509            }
1510        }
1511
1512        pub type Response404 = ApiError;
1513
1514        pub type Response = Response200;
1515    }
1516}
1517pub mod servers_server_schedules_schedule_abort {
1518    use super::*;
1519
1520    pub mod post {
1521        use super::*;
1522
1523        nestify::nest! {
1524            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1525            }
1526        }
1527
1528        pub type Response404 = ApiError;
1529
1530        pub type Response = Response200;
1531    }
1532}
1533pub mod servers_server_schedules_schedule_trigger {
1534    use super::*;
1535
1536    pub mod post {
1537        use super::*;
1538
1539        nestify::nest! {
1540            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1541                #[schema(inline)]
1542                pub skip_condition: bool,
1543            }
1544        }
1545
1546        nestify::nest! {
1547            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1548            }
1549        }
1550
1551        pub type Response404 = ApiError;
1552
1553        pub type Response = Response200;
1554    }
1555}
1556pub mod servers_server_script {
1557    use super::*;
1558
1559    pub mod post {
1560        use super::*;
1561
1562        pub type RequestBody = InstallationScript;
1563
1564        pub type Response200 = AsyncResponseReader;
1565
1566        pub type Response = Response200;
1567    }
1568}
1569pub mod servers_server_sync {
1570    use super::*;
1571
1572    pub mod post {
1573        use super::*;
1574
1575        nestify::nest! {
1576            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1577                #[schema(inline)]
1578                pub server: serde_json::Value,
1579            }
1580        }
1581
1582        nestify::nest! {
1583            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1584            }
1585        }
1586
1587        pub type Response = Response200;
1588    }
1589}
1590pub mod servers_server_transfer {
1591    use super::*;
1592
1593    pub mod delete {
1594        use super::*;
1595
1596        nestify::nest! {
1597            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1598            }
1599        }
1600
1601        pub type Response417 = ApiError;
1602
1603        pub type Response = Response200;
1604    }
1605
1606    pub mod post {
1607        use super::*;
1608
1609        nestify::nest! {
1610            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1611                #[schema(inline)]
1612                pub url: compact_str::CompactString,
1613                #[schema(inline)]
1614                pub token: compact_str::CompactString,
1615                #[schema(inline)]
1616                pub archive_format: TransferArchiveFormat,
1617                #[schema(inline)]
1618                pub compression_level: Option<CompressionLevel>,
1619                #[schema(inline)]
1620                pub backups: Vec<uuid::Uuid>,
1621                #[schema(inline)]
1622                pub delete_backups: bool,
1623                #[schema(inline)]
1624                pub multiplex_streams: u64,
1625            }
1626        }
1627
1628        nestify::nest! {
1629            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1630            }
1631        }
1632
1633        pub type Response409 = ApiError;
1634
1635        pub type Response = Response202;
1636    }
1637}
1638pub mod servers_server_utilization {
1639    use super::*;
1640
1641    pub mod get {
1642        use super::*;
1643
1644        nestify::nest! {
1645            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1646                #[schema(inline)]
1647                pub utilization: ResourceUsage,
1648            }
1649        }
1650
1651        pub type Response404 = ApiError;
1652
1653        pub type Response = Response200;
1654    }
1655}
1656pub mod servers_server_version {
1657    use super::*;
1658
1659    pub mod get {
1660        use super::*;
1661
1662        nestify::nest! {
1663            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1664                #[schema(inline)]
1665                pub hash: compact_str::CompactString,
1666            }
1667        }
1668
1669        pub type Response404 = ApiError;
1670
1671        pub type Response = Response200;
1672    }
1673}
1674pub mod servers_server_ws_broadcast {
1675    use super::*;
1676
1677    pub mod post {
1678        use super::*;
1679
1680        nestify::nest! {
1681            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1682                #[schema(inline)]
1683                pub users: Vec<uuid::Uuid>,
1684                #[schema(inline)]
1685                pub permissions: Vec<compact_str::CompactString>,
1686                #[schema(inline)]
1687                pub message: WebsocketMessage,
1688            }
1689        }
1690
1691        nestify::nest! {
1692            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1693            }
1694        }
1695
1696        pub type Response = Response200;
1697    }
1698}
1699pub mod servers_server_ws_deny {
1700    use super::*;
1701
1702    pub mod post {
1703        use super::*;
1704
1705        nestify::nest! {
1706            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1707                #[schema(inline)]
1708                pub jtis: Vec<compact_str::CompactString>,
1709            }
1710        }
1711
1712        nestify::nest! {
1713            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1714            }
1715        }
1716
1717        pub type Response = Response200;
1718    }
1719}
1720pub mod servers_server_ws_permissions {
1721    use super::*;
1722
1723    pub mod post {
1724        use super::*;
1725
1726        nestify::nest! {
1727            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1728                #[schema(inline)]
1729                pub user_permissions: Vec<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodyUserPermissions {
1730                    #[schema(inline)]
1731                    pub user: uuid::Uuid,
1732                    #[schema(inline)]
1733                    pub permissions: Vec<compact_str::CompactString>,
1734                    #[schema(inline)]
1735                    pub ignored_files: Vec<compact_str::CompactString>,
1736                }>,
1737            }
1738        }
1739
1740        nestify::nest! {
1741            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1742            }
1743        }
1744
1745        pub type Response = Response200;
1746    }
1747}
1748pub mod system {
1749    use super::*;
1750
1751    pub mod get {
1752        use super::*;
1753
1754        nestify::nest! {
1755            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1756                #[schema(inline)]
1757                pub architecture: compact_str::CompactString,
1758                #[schema(inline)]
1759                pub cpu_count: u64,
1760                #[schema(inline)]
1761                pub kernel_version: compact_str::CompactString,
1762                #[schema(inline)]
1763                pub os: compact_str::CompactString,
1764                #[schema(inline)]
1765                pub version: compact_str::CompactString,
1766            }
1767        }
1768
1769        pub type Response = Response200;
1770    }
1771}
1772pub mod system_config {
1773    use super::*;
1774
1775    pub mod get {
1776        use super::*;
1777
1778        nestify::nest! {
1779            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1780                #[schema(inline)]
1781                pub debug: bool,
1782                #[schema(inline)]
1783                pub app_name: compact_str::CompactString,
1784                #[schema(inline)]
1785                pub uuid: uuid::Uuid,
1786                #[schema(inline)]
1787                pub token_id: compact_str::CompactString,
1788                #[schema(inline)]
1789                pub token: compact_str::CompactString,
1790                #[schema(inline)]
1791                pub api: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200Api {
1792                    #[schema(inline)]
1793                    pub host: compact_str::CompactString,
1794                    #[schema(inline)]
1795                    pub port: u32,
1796                    #[schema(inline)]
1797                    pub ssl: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200ApiSsl {
1798                        #[schema(inline)]
1799                        pub enabled: bool,
1800                        #[schema(inline)]
1801                        pub cert: compact_str::CompactString,
1802                        #[schema(inline)]
1803                        pub key: compact_str::CompactString,
1804                    },
1805
1806                    #[schema(inline)]
1807                    pub redirects: IndexMap<compact_str::CompactString, compact_str::CompactString>,
1808                    #[schema(inline)]
1809                    pub disable_openapi_docs: bool,
1810                    #[schema(inline)]
1811                    pub disable_remote_download: bool,
1812                    #[schema(inline)]
1813                    pub server_remote_download_limit: u64,
1814                    #[schema(inline)]
1815                    pub remote_download_blocked_cidrs: Vec<compact_str::CompactString>,
1816                    #[schema(inline)]
1817                    pub disable_directory_size: bool,
1818                    #[schema(inline)]
1819                    pub directory_entry_limit: u64,
1820                    #[schema(inline)]
1821                    pub send_offline_server_logs: bool,
1822                    #[schema(inline)]
1823                    pub file_search_threads: u64,
1824                    #[schema(inline)]
1825                    pub file_copy_threads: u64,
1826                    #[schema(inline)]
1827                    pub file_decompression_threads: u64,
1828                    #[schema(inline)]
1829                    pub file_compression_threads: u64,
1830                    #[schema(inline)]
1831                    pub upload_limit: MiB,
1832                    #[schema(inline)]
1833                    pub max_jwt_uses: u64,
1834                    #[schema(inline)]
1835                    pub trusted_proxies: Vec<compact_str::CompactString>,
1836                },
1837
1838                #[schema(inline)]
1839                pub system: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200System {
1840                    #[schema(inline)]
1841                    pub root_directory: compact_str::CompactString,
1842                    #[schema(inline)]
1843                    pub log_directory: compact_str::CompactString,
1844                    #[schema(inline)]
1845                    pub vmount_directory: compact_str::CompactString,
1846                    #[schema(inline)]
1847                    pub data: compact_str::CompactString,
1848                    #[schema(inline)]
1849                    pub archive_directory: compact_str::CompactString,
1850                    #[schema(inline)]
1851                    pub backup_directory: compact_str::CompactString,
1852                    #[schema(inline)]
1853                    pub tmp_directory: compact_str::CompactString,
1854                    #[schema(inline)]
1855                    pub username: compact_str::CompactString,
1856                    #[schema(inline)]
1857                    pub timezone: compact_str::CompactString,
1858                    #[schema(inline)]
1859                    pub user: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemUser {
1860                        #[schema(inline)]
1861                        pub rootless: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemUserRootless {
1862                            #[schema(inline)]
1863                            pub enabled: bool,
1864                            #[schema(inline)]
1865                            pub container_uid: u32,
1866                            #[schema(inline)]
1867                            pub container_gid: u32,
1868                        },
1869
1870                        #[schema(inline)]
1871                        pub uid: u32,
1872                        #[schema(inline)]
1873                        pub gid: u32,
1874                    },
1875
1876                    #[schema(inline)]
1877                    pub passwd: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemPasswd {
1878                        #[schema(inline)]
1879                        pub enabled: bool,
1880                        #[schema(inline)]
1881                        pub directory: compact_str::CompactString,
1882                    },
1883
1884                    #[schema(inline)]
1885                    pub machine_id: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemMachineId {
1886                        #[schema(inline)]
1887                        pub enabled: bool,
1888                    },
1889
1890                    #[schema(inline)]
1891                    pub disk_check_concurrency: u64,
1892                    #[schema(inline)]
1893                    pub disk_check_interval: u64,
1894                    #[schema(inline)]
1895                    pub full_disk_check_every: u64,
1896                    #[schema(inline)]
1897                    pub disk_check_use_inotify: bool,
1898                    #[schema(inline)]
1899                    pub disk_limiter_mode: DiskLimiterMode,
1900                    #[schema(inline)]
1901                    pub activity_send_interval: u64,
1902                    #[schema(inline)]
1903                    pub activity_send_count: u64,
1904                    #[schema(inline)]
1905                    pub check_permissions_on_boot: bool,
1906                    #[schema(inline)]
1907                    pub check_permissions_on_boot_threads: u64,
1908                    #[schema(inline)]
1909                    pub websocket_log_count: u64,
1910                    #[schema(inline)]
1911                    pub sftp: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemSftp {
1912                        #[schema(inline)]
1913                        pub enabled: bool,
1914                        #[schema(inline)]
1915                        pub bind_address: compact_str::CompactString,
1916                        #[schema(inline)]
1917                        pub bind_port: u32,
1918                        #[schema(inline)]
1919                        pub read_only: bool,
1920                        #[schema(inline)]
1921                        pub key_algorithm: compact_str::CompactString,
1922                        #[schema(inline)]
1923                        pub disable_password_auth: bool,
1924                        #[schema(inline)]
1925                        pub directory_entry_limit: u64,
1926                        #[schema(inline)]
1927                        pub directory_entry_send_amount: u64,
1928                        #[schema(inline)]
1929                        pub limits: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemSftpLimits {
1930                            #[schema(inline)]
1931                            pub authentication_password_attempts: u64,
1932                            #[schema(inline)]
1933                            pub authentication_pubkey_attempts: u64,
1934                            #[schema(inline)]
1935                            pub authentication_cooldown: u64,
1936                        },
1937
1938                        #[schema(inline)]
1939                        pub shell: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemSftpShell {
1940                            #[schema(inline)]
1941                            pub enabled: bool,
1942                            #[schema(inline)]
1943                            pub cli: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemSftpShellCli {
1944                                #[schema(inline)]
1945                                pub name: compact_str::CompactString,
1946                            },
1947
1948                        },
1949
1950                        #[schema(inline)]
1951                        pub activity: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemSftpActivity {
1952                            #[schema(inline)]
1953                            pub log_logins: bool,
1954                            #[schema(inline)]
1955                            pub log_file_reads: bool,
1956                        },
1957
1958                    },
1959
1960                    #[schema(inline)]
1961                    pub crash_detection: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemCrashDetection {
1962                        #[schema(inline)]
1963                        pub enabled: bool,
1964                        #[schema(inline)]
1965                        pub detect_clean_exit_as_crash: bool,
1966                        #[schema(inline)]
1967                        pub timeout: u64,
1968                    },
1969
1970                    #[schema(inline)]
1971                    pub backups: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackups {
1972                        #[schema(inline)]
1973                        pub write_limit: MiB,
1974                        #[schema(inline)]
1975                        pub read_limit: MiB,
1976                        #[schema(inline)]
1977                        pub compression_level: CompressionLevel,
1978                        #[schema(inline)]
1979                        pub mounting: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsMounting {
1980                            #[schema(inline)]
1981                            pub enabled: bool,
1982                            #[schema(inline)]
1983                            pub path: compact_str::CompactString,
1984                        },
1985
1986                        #[schema(inline)]
1987                        pub wings: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsWings {
1988                            #[schema(inline)]
1989                            pub create_threads: u64,
1990                            #[schema(inline)]
1991                            pub restore_threads: u64,
1992                            #[schema(inline)]
1993                            pub archive_format: ArchiveFormat,
1994                        },
1995
1996                        #[schema(inline)]
1997                        pub s3: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsS3 {
1998                            #[schema(inline)]
1999                            pub create_threads: u64,
2000                            #[schema(inline)]
2001                            pub part_upload_timeout: u64,
2002                            #[schema(inline)]
2003                            pub retry_limit: u64,
2004                        },
2005
2006                        #[schema(inline)]
2007                        pub ddup_bak: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsDdupBak {
2008                            #[schema(inline)]
2009                            pub create_threads: u64,
2010                            #[schema(inline)]
2011                            pub compression_format: SystemBackupsDdupBakCompressionFormat,
2012                        },
2013
2014                        #[schema(inline)]
2015                        pub restic: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsRestic {
2016                            #[schema(inline)]
2017                            pub repository: compact_str::CompactString,
2018                            #[schema(inline)]
2019                            pub password_file: compact_str::CompactString,
2020                            #[schema(inline)]
2021                            pub retry_lock_seconds: u64,
2022                            #[schema(inline)]
2023                            pub environment: IndexMap<compact_str::CompactString, compact_str::CompactString>,
2024                        },
2025
2026                        #[schema(inline)]
2027                        pub btrfs: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsBtrfs {
2028                            #[schema(inline)]
2029                            pub restore_threads: u64,
2030                            #[schema(inline)]
2031                            pub create_read_only: bool,
2032                        },
2033
2034                        #[schema(inline)]
2035                        pub zfs: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsZfs {
2036                            #[schema(inline)]
2037                            pub restore_threads: u64,
2038                        },
2039
2040                    },
2041
2042                    #[schema(inline)]
2043                    pub transfers: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemTransfers {
2044                        #[schema(inline)]
2045                        pub download_limit: MiB,
2046                    },
2047
2048                },
2049
2050                #[schema(inline)]
2051                pub docker: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200Docker {
2052                    #[schema(inline)]
2053                    pub socket: compact_str::CompactString,
2054                    #[schema(inline)]
2055                    pub server_name_in_container_name: bool,
2056                    #[schema(inline)]
2057                    pub delete_container_on_stop: bool,
2058                    #[schema(inline)]
2059                    pub network: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerNetwork {
2060                        #[schema(inline)]
2061                        pub interface: compact_str::CompactString,
2062                        #[schema(inline)]
2063                        pub disable_interface_binding: bool,
2064                        #[schema(inline)]
2065                        pub dns: Vec<compact_str::CompactString>,
2066                        #[schema(inline)]
2067                        pub name: compact_str::CompactString,
2068                        #[schema(inline)]
2069                        pub ispn: bool,
2070                        #[schema(inline)]
2071                        pub driver: compact_str::CompactString,
2072                        #[schema(inline)]
2073                        pub mode: compact_str::CompactString,
2074                        #[schema(inline)]
2075                        pub is_internal: bool,
2076                        #[schema(inline)]
2077                        pub enable_icc: bool,
2078                        #[schema(inline)]
2079                        pub network_mtu: u64,
2080                        #[schema(inline)]
2081                        pub interfaces: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerNetworkInterfaces {
2082                            #[schema(inline)]
2083                            pub v4: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerNetworkInterfacesV4 {
2084                                #[schema(inline)]
2085                                pub subnet: compact_str::CompactString,
2086                                #[schema(inline)]
2087                                pub gateway: compact_str::CompactString,
2088                            },
2089
2090                            #[schema(inline)]
2091                            pub v6: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerNetworkInterfacesV6 {
2092                                #[schema(inline)]
2093                                pub subnet: compact_str::CompactString,
2094                                #[schema(inline)]
2095                                pub gateway: compact_str::CompactString,
2096                            },
2097
2098                        },
2099
2100                    },
2101
2102                    #[schema(inline)]
2103                    pub domainname: compact_str::CompactString,
2104                    #[schema(inline)]
2105                    pub registries: IndexMap<compact_str::CompactString, serde_json::Value>,
2106                    #[schema(inline)]
2107                    pub tmpfs_size: u64,
2108                    #[schema(inline)]
2109                    pub container_pid_limit: u64,
2110                    #[schema(inline)]
2111                    pub installer_limits: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerInstallerLimits {
2112                        #[schema(inline)]
2113                        pub timeout: u64,
2114                        #[schema(inline)]
2115                        pub memory: MiB,
2116                        #[schema(inline)]
2117                        pub cpu: u64,
2118                    },
2119
2120                    #[schema(inline)]
2121                    pub overhead: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerOverhead {
2122                        #[schema(inline)]
2123                        pub r#override: bool,
2124                        #[schema(inline)]
2125                        pub default_multiplier: f64,
2126                        #[schema(inline)]
2127                        pub multipliers: IndexMap<compact_str::CompactString, f64>,
2128                    },
2129
2130                    #[schema(inline)]
2131                    pub userns_mode: compact_str::CompactString,
2132                    #[schema(inline)]
2133                    pub log_config: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerLogConfig {
2134                        #[schema(inline)]
2135                        pub r#type: compact_str::CompactString,
2136                        #[schema(inline)]
2137                        pub config: IndexMap<compact_str::CompactString, compact_str::CompactString>,
2138                    },
2139
2140                },
2141
2142                #[schema(inline)]
2143                pub throttles: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200Throttles {
2144                    #[schema(inline)]
2145                    pub enabled: bool,
2146                    #[schema(inline)]
2147                    pub lines: u64,
2148                    #[schema(inline)]
2149                    pub line_reset_interval: u64,
2150                },
2151
2152                #[schema(inline)]
2153                pub remote: compact_str::CompactString,
2154                #[schema(inline)]
2155                pub remote_headers: IndexMap<compact_str::CompactString, compact_str::CompactString>,
2156                #[schema(inline)]
2157                pub remote_query: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200RemoteQuery {
2158                    #[schema(inline)]
2159                    pub timeout: u64,
2160                    #[schema(inline)]
2161                    pub boot_servers_per_page: u64,
2162                    #[schema(inline)]
2163                    pub retry_limit: u64,
2164                },
2165
2166                #[schema(inline)]
2167                pub allowed_mounts: Vec<compact_str::CompactString>,
2168                #[schema(inline)]
2169                pub allowed_origins: Vec<compact_str::CompactString>,
2170                #[schema(inline)]
2171                pub allow_cors_private_network: bool,
2172                #[schema(inline)]
2173                pub ignore_panel_config_updates: bool,
2174                #[schema(inline)]
2175                pub ignore_panel_wings_upgrades: bool,
2176            }
2177        }
2178
2179        pub type Response = Response200;
2180    }
2181}
2182pub mod system_logs {
2183    use super::*;
2184
2185    pub mod get {
2186        use super::*;
2187
2188        nestify::nest! {
2189            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2190                #[schema(inline)]
2191                pub log_files: Vec<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200LogFiles {
2192                    #[schema(inline)]
2193                    pub name: compact_str::CompactString,
2194                    #[schema(inline)]
2195                    pub size: u64,
2196                    #[schema(inline)]
2197                    pub last_modified: chrono::DateTime<chrono::Local>,
2198                }>,
2199            }
2200        }
2201
2202        pub type Response = Response200;
2203    }
2204}
2205pub mod system_logs_file {
2206    use super::*;
2207
2208    pub mod get {
2209        use super::*;
2210
2211        pub type Response200 = AsyncResponseReader;
2212
2213        pub type Response404 = ApiError;
2214
2215        pub type Response = Response200;
2216    }
2217}
2218pub mod system_overview {
2219    use super::*;
2220
2221    pub mod get {
2222        use super::*;
2223
2224        nestify::nest! {
2225            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2226                #[schema(inline)]
2227                pub version: compact_str::CompactString,
2228                #[schema(inline)]
2229                pub local_time: chrono::DateTime<chrono::Local>,
2230                #[schema(inline)]
2231                pub container_type: AppContainerType,
2232                #[schema(inline)]
2233                pub cpu: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200Cpu {
2234                    #[schema(inline)]
2235                    pub name: compact_str::CompactString,
2236                    #[schema(inline)]
2237                    pub brand: compact_str::CompactString,
2238                    #[schema(inline)]
2239                    pub vendor_id: compact_str::CompactString,
2240                    #[schema(inline)]
2241                    pub frequency_mhz: u64,
2242                    #[schema(inline)]
2243                    pub cpu_count: u64,
2244                },
2245
2246                #[schema(inline)]
2247                pub memory: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200Memory {
2248                    #[schema(inline)]
2249                    pub total_bytes: u64,
2250                    #[schema(inline)]
2251                    pub free_bytes: u64,
2252                    #[schema(inline)]
2253                    pub used_bytes: u64,
2254                    #[schema(inline)]
2255                    pub used_bytes_process: u64,
2256                },
2257
2258                #[schema(inline)]
2259                pub servers: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200Servers {
2260                    #[schema(inline)]
2261                    pub total: u64,
2262                    #[schema(inline)]
2263                    pub online: u64,
2264                    #[schema(inline)]
2265                    pub offline: u64,
2266                },
2267
2268                #[schema(inline)]
2269                pub architecture: compact_str::CompactString,
2270                #[schema(inline)]
2271                pub kernel_version: compact_str::CompactString,
2272            }
2273        }
2274
2275        pub type Response = Response200;
2276    }
2277}
2278pub mod system_stats {
2279    use super::*;
2280
2281    pub mod get {
2282        use super::*;
2283
2284        nestify::nest! {
2285            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2286                #[schema(inline)]
2287                pub stats: SystemStats,
2288            }
2289        }
2290
2291        pub type Response = Response200;
2292    }
2293}
2294pub mod system_upgrade {
2295    use super::*;
2296
2297    pub mod post {
2298        use super::*;
2299
2300        nestify::nest! {
2301            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
2302                #[schema(inline)]
2303                pub url: compact_str::CompactString,
2304                #[schema(inline)]
2305                pub headers: IndexMap<compact_str::CompactString, compact_str::CompactString>,
2306                #[schema(inline)]
2307                pub sha256: compact_str::CompactString,
2308                #[schema(inline)]
2309                pub restart_command: compact_str::CompactString,
2310                #[schema(inline)]
2311                pub restart_command_args: Vec<compact_str::CompactString>,
2312            }
2313        }
2314
2315        nestify::nest! {
2316            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
2317                #[schema(inline)]
2318                pub applied: bool,
2319            }
2320        }
2321
2322        nestify::nest! {
2323            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response409 {
2324                #[schema(inline)]
2325                pub error: compact_str::CompactString,
2326            }
2327        }
2328
2329        pub type Response = Response202;
2330    }
2331}
2332pub mod transfers {
2333    use super::*;
2334
2335    pub mod get {
2336        use super::*;
2337
2338        type Response200 = IndexMap<uuid::Uuid, TransferProgress>;
2339        pub type Response404 = ApiError;
2340
2341        pub type Response = Response200;
2342    }
2343
2344    pub mod post {
2345        use super::*;
2346
2347        nestify::nest! {
2348            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2349            }
2350        }
2351
2352        pub type Response401 = ApiError;
2353
2354        pub type Response409 = ApiError;
2355
2356        pub type Response = Response200;
2357    }
2358}
2359pub mod transfers_files {
2360    use super::*;
2361
2362    pub mod post {
2363        use super::*;
2364
2365        nestify::nest! {
2366            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2367            }
2368        }
2369
2370        pub type Response401 = ApiError;
2371
2372        pub type Response409 = ApiError;
2373
2374        pub type Response = Response200;
2375    }
2376}
2377pub mod transfers_server {
2378    use super::*;
2379
2380    pub mod delete {
2381        use super::*;
2382
2383        nestify::nest! {
2384            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2385            }
2386        }
2387
2388        pub type Response404 = ApiError;
2389
2390        pub type Response = Response200;
2391    }
2392}
2393pub mod update {
2394    use super::*;
2395
2396    pub mod post {
2397        use super::*;
2398
2399        nestify::nest! {
2400            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
2401                #[schema(inline)]
2402                pub debug: Option<bool>,
2403                #[schema(inline)]
2404                pub app_name: Option<compact_str::CompactString>,
2405                #[schema(inline)]
2406                pub api: Option<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodyApi {
2407                    #[schema(inline)]
2408                    pub host: Option<compact_str::CompactString>,
2409                    #[schema(inline)]
2410                    pub port: Option<u32>,
2411                    #[schema(inline)]
2412                    pub ssl: Option<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodyApiSsl {
2413                        #[schema(inline)]
2414                        pub enabled: Option<bool>,
2415                        #[schema(inline)]
2416                        pub cert: Option<compact_str::CompactString>,
2417                        #[schema(inline)]
2418                        pub key: Option<compact_str::CompactString>,
2419                    }>,
2420                    #[schema(inline)]
2421                    pub upload_limit: Option<MiB>,
2422                }>,
2423                #[schema(inline)]
2424                pub system: Option<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodySystem {
2425                    #[schema(inline)]
2426                    pub sftp: Option<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodySystemSftp {
2427                        #[schema(inline)]
2428                        pub bind_address: Option<compact_str::CompactString>,
2429                        #[schema(inline)]
2430                        pub bind_port: Option<u32>,
2431                    }>,
2432                }>,
2433                #[schema(inline)]
2434                pub allowed_origins: Option<Vec<compact_str::CompactString>>,
2435                #[schema(inline)]
2436                pub allow_cors_private_network: Option<bool>,
2437                #[schema(inline)]
2438                pub ignore_panel_config_updates: Option<bool>,
2439            }
2440        }
2441
2442        nestify::nest! {
2443            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2444                #[schema(inline)]
2445                pub applied: bool,
2446            }
2447        }
2448
2449        pub type Response = Response200;
2450    }
2451}
wings_api/lib.rs

wings_api/
lib.rs
