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

wings_api/
lib.rs
