Skip to main content

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;
14pub mod tunnel;
15
16use client::{AsyncRequestReader, AsyncResponseReader};
17pub use extra::*;
18
19nestify::nest! {
20    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ApiError {
21        #[schema(inline)]
22        pub error: compact_str::CompactString,
23    }
24}
25
26#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
27pub enum AppContainerType {
28    #[serde(rename = "official")]
29    Official,
30    #[serde(rename = "unknown")]
31    Unknown,
32    #[serde(rename = "none")]
33    None,
34}
35
36#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
37pub enum ArchiveFormat {
38    #[serde(rename = "tar")]
39    Tar,
40    #[serde(rename = "tar_gz")]
41    TarGz,
42    #[serde(rename = "tar_xz")]
43    TarXz,
44    #[serde(rename = "tar_lzip")]
45    TarLzip,
46    #[serde(rename = "tar_bz2")]
47    TarBz2,
48    #[serde(rename = "tar_lz4")]
49    TarLz4,
50    #[serde(rename = "tar_zstd")]
51    TarZstd,
52    #[serde(rename = "zip")]
53    Zip,
54    #[serde(rename = "seven_zip")]
55    SevenZip,
56}
57
58#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
59pub enum BackupAdapter {
60    #[serde(rename = "wings")]
61    Wings,
62    #[serde(rename = "s3")]
63    S3,
64    #[serde(rename = "ddup-bak")]
65    DdupBak,
66    #[serde(rename = "btrfs")]
67    Btrfs,
68    #[serde(rename = "zfs")]
69    Zfs,
70    #[serde(rename = "restic")]
71    Restic,
72    #[serde(rename = "proxmox-backup-server")]
73    ProxmoxBackupServer,
74    #[serde(rename = "kopia")]
75    Kopia,
76}
77
78#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
79pub enum CompressionLevel {
80    #[serde(rename = "best_speed")]
81    BestSpeed,
82    #[serde(rename = "good_speed")]
83    GoodSpeed,
84    #[serde(rename = "good_compression")]
85    GoodCompression,
86    #[serde(rename = "best_compression")]
87    BestCompression,
88}
89
90#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
91pub enum CompressionType {
92    #[serde(rename = "none")]
93    None,
94    #[serde(rename = "gz")]
95    Gz,
96    #[serde(rename = "xz")]
97    Xz,
98    #[serde(rename = "lzip")]
99    Lzip,
100    #[serde(rename = "bz2")]
101    Bz2,
102    #[serde(rename = "lz4")]
103    Lz4,
104    #[serde(rename = "zstd")]
105    Zstd,
106}
107
108nestify::nest! {
109    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct CopyFile {
110        #[schema(inline)]
111        pub from: compact_str::CompactString,
112        #[schema(inline)]
113        pub to: compact_str::CompactString,
114    }
115}
116
117nestify::nest! {
118    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct DirectoryEntry {
119        #[schema(inline)]
120        pub name: compact_str::CompactString,
121        #[schema(inline)]
122        pub mode: compact_str::CompactString,
123        #[schema(inline)]
124        pub mode_bits: compact_str::CompactString,
125        #[schema(inline)]
126        pub size: u64,
127        #[schema(inline)]
128        pub size_physical: u64,
129        #[schema(inline)]
130        pub editable: bool,
131        #[schema(inline)]
132        pub inner_editable: bool,
133        #[schema(inline)]
134        pub directory: bool,
135        #[schema(inline)]
136        pub file: bool,
137        #[schema(inline)]
138        pub symlink: bool,
139        #[schema(inline)]
140        pub r#virtual: bool,
141        #[schema(inline)]
142        pub mime: compact_str::CompactString,
143        #[schema(inline)]
144        pub created: chrono::DateTime<chrono::Local>,
145        #[schema(inline)]
146        pub modified: chrono::DateTime<chrono::Local>,
147    }
148}
149
150#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
151pub enum DiskLimiterMode {
152    #[serde(rename = "none")]
153    None,
154    #[serde(rename = "btrfs_subvolume")]
155    BtrfsSubvolume,
156    #[serde(rename = "zfs_dataset")]
157    ZfsDataset,
158    #[serde(rename = "xfs_quota")]
159    XfsQuota,
160    #[serde(rename = "fuse_quota")]
161    FuseQuota,
162}
163
164nestify::nest! {
165    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Download {
166        #[schema(inline)]
167        pub identifier: uuid::Uuid,
168        #[schema(inline)]
169        pub destination: compact_str::CompactString,
170        #[schema(inline)]
171        pub progress: u64,
172        #[schema(inline)]
173        pub total: u64,
174    }
175}
176
177nestify::nest! {
178    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct FilesystemOperation {
179    }
180}
181
182nestify::nest! {
183    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct InstallationScript {
184        #[schema(inline)]
185        pub container_image: compact_str::CompactString,
186        #[schema(inline)]
187        pub entrypoint: compact_str::CompactString,
188        #[schema(inline)]
189        pub script: compact_str::CompactString,
190        #[schema(inline)]
191        pub environment: IndexMap<compact_str::CompactString, serde_json::Value>,
192    }
193}
194
195pub type MiB = u64;
196
197nestify::nest! {
198    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Mount {
199        #[schema(inline)]
200        pub target: compact_str::CompactString,
201        #[schema(inline)]
202        pub source: compact_str::CompactString,
203        #[schema(inline)]
204        pub read_only: bool,
205    }
206}
207
208nestify::nest! {
209    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct QueryColumn {
210        #[schema(inline)]
211        pub name: compact_str::CompactString,
212        #[schema(inline)]
213        pub type_name: compact_str::CompactString,
214        #[schema(inline)]
215        pub binary: bool,
216    }
217}
218
219nestify::nest! {
220    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct QueryResultSet {
221        #[schema(inline)]
222        pub columns: Vec<QueryColumn>,
223        #[schema(inline)]
224        pub rows: Vec<Vec<QueryValue>>,
225        #[schema(inline)]
226        pub rows_affected: u64,
227        #[schema(inline)]
228        pub truncated: bool,
229    }
230}
231
232nestify::nest! {
233    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ResourceUsage {
234        #[schema(inline)]
235        pub memory_bytes: u64,
236        #[schema(inline)]
237        pub memory_limit_bytes: u64,
238        #[schema(inline)]
239        pub disk_bytes: u64,
240        #[schema(inline)]
241        pub state: ServerState,
242        #[schema(inline)]
243        pub network: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ResourceUsageNetwork {
244            #[schema(inline)]
245            pub rx_bytes: u64,
246            #[schema(inline)]
247            pub rx_packets: u64,
248            #[schema(inline)]
249            pub tx_bytes: u64,
250            #[schema(inline)]
251            pub tx_packets: u64,
252        },
253
254        #[schema(inline)]
255        pub cpu_absolute: f64,
256        #[schema(inline)]
257        pub cpu_limit_absolute: u32,
258        #[schema(inline)]
259        pub uptime: u64,
260    }
261}
262
263nestify::nest! {
264    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ResticBackupConfiguration {
265        #[schema(inline)]
266        pub repository: compact_str::CompactString,
267        #[schema(inline)]
268        pub password_file: Option<compact_str::CompactString>,
269        #[schema(inline)]
270        pub retry_lock_seconds: u64,
271        #[schema(inline)]
272        pub environment: IndexMap<compact_str::CompactString, compact_str::CompactString>,
273    }
274}
275
276nestify::nest! {
277    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ResticTaskResult {
278        #[schema(inline)]
279        pub started: chrono::DateTime<chrono::Local>,
280        #[schema(inline)]
281        pub finished: chrono::DateTime<chrono::Local>,
282        #[schema(inline)]
283        pub duration_ms: u64,
284        #[schema(inline)]
285        pub successful: bool,
286        #[schema(inline)]
287        pub data: serde_json::Value,
288        #[schema(inline)]
289        pub stderr: compact_str::CompactString,
290    }
291}
292
293nestify::nest! {
294    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RevisionInfo {
295        #[schema(inline)]
296        pub id: i64,
297        #[schema(inline)]
298        pub size: u64,
299        #[schema(inline)]
300        pub stored_size: u64,
301        #[schema(inline)]
302        pub user: Option<uuid::Uuid>,
303        #[schema(inline)]
304        pub is_snapshot: bool,
305        #[schema(inline)]
306        pub created: chrono::DateTime<chrono::Local>,
307    }
308}
309
310nestify::nest! {
311    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Schedule {
312        #[schema(inline)]
313        pub uuid: uuid::Uuid,
314        #[schema(inline)]
315        pub triggers: serde_json::Value,
316        #[schema(inline)]
317        pub condition: serde_json::Value,
318        #[schema(inline)]
319        pub actions: Vec<serde_json::Value>,
320    }
321}
322
323nestify::nest! {
324    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ScheduleStatus {
325        #[schema(inline)]
326        pub running: bool,
327        #[schema(inline)]
328        pub errors: IndexMap<uuid::Uuid, compact_str::CompactString>,
329        #[schema(inline)]
330        pub step: Option<uuid::Uuid>,
331    }
332}
333
334nestify::nest! {
335    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Server {
336        #[schema(inline)]
337        pub state: ServerState,
338        #[schema(inline)]
339        pub is_suspended: bool,
340        #[schema(inline)]
341        pub utilization: ResourceUsage,
342        #[schema(inline)]
343        pub configuration: ServerConfiguration,
344    }
345}
346
347#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
348pub enum ServerAutoStartBehavior {
349    #[serde(rename = "always")]
350    Always,
351    #[serde(rename = "unless_stopped")]
352    UnlessStopped,
353    #[serde(rename = "never")]
354    Never,
355}
356
357nestify::nest! {
358    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfiguration {
359        #[schema(inline)]
360        pub uuid: uuid::Uuid,
361        #[schema(inline)]
362        pub start_on_completion: Option<bool>,
363        #[schema(inline)]
364        pub meta: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationMeta {
365            #[schema(inline)]
366            pub name: compact_str::CompactString,
367            #[schema(inline)]
368            pub description: compact_str::CompactString,
369        },
370
371        #[schema(inline)]
372        pub suspended: bool,
373        #[schema(inline)]
374        pub invocation: compact_str::CompactString,
375        #[schema(inline)]
376        pub skip_egg_scripts: bool,
377        #[schema(inline)]
378        pub entrypoint: Option<Vec<compact_str::CompactString>>,
379        #[schema(inline)]
380        pub environment: IndexMap<compact_str::CompactString, serde_json::Value>,
381        #[schema(inline)]
382        pub labels: IndexMap<compact_str::CompactString, compact_str::CompactString>,
383        #[schema(inline)]
384        pub backups: Vec<uuid::Uuid>,
385        #[schema(inline)]
386        pub schedules: Vec<Schedule>,
387        #[schema(inline)]
388        pub allocations: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationAllocations {
389            #[schema(inline)]
390            pub force_outgoing_ip: bool,
391            #[schema(inline)]
392            pub default: Option<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationAllocationsDefault {
393                #[schema(inline)]
394                pub ip: compact_str::CompactString,
395                #[schema(inline)]
396                pub port: u32,
397            }>,
398            #[schema(inline)]
399            pub mappings: IndexMap<compact_str::CompactString, Vec<u32>>,
400        },
401
402        #[schema(inline)]
403        pub build: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationBuild {
404            #[schema(inline)]
405            pub memory_limit: i64,
406            #[schema(inline)]
407            pub overhead_memory: i64,
408            #[schema(inline)]
409            pub swap: i64,
410            #[schema(inline)]
411            pub io_weight: Option<u32>,
412            #[schema(inline)]
413            pub cpu_limit: i64,
414            #[schema(inline)]
415            pub disk_space: u64,
416            #[schema(inline)]
417            pub threads: Option<compact_str::CompactString>,
418            #[schema(inline)]
419            pub oom_disabled: bool,
420        },
421
422        #[schema(inline)]
423        pub mounts: Vec<Mount>,
424        #[schema(inline)]
425        pub egg: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationEgg {
426            #[schema(inline)]
427            pub id: uuid::Uuid,
428            #[schema(inline)]
429            pub file_denylist: Vec<compact_str::CompactString>,
430        },
431
432        #[schema(inline)]
433        pub container: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationContainer {
434            #[schema(inline)]
435            pub image: compact_str::CompactString,
436            #[schema(inline)]
437            pub timezone: Option<compact_str::CompactString>,
438            #[schema(inline)]
439            pub hugepages_passthrough_enabled: bool,
440            #[schema(inline)]
441            pub kvm_passthrough_enabled: bool,
442            #[schema(inline)]
443            pub seccomp: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationContainerSeccomp {
444                #[schema(inline)]
445                pub remove_allowed: Vec<compact_str::CompactString>,
446            },
447
448        },
449
450        #[schema(inline)]
451        pub auto_kill: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct ServerConfigurationAutoKill {
452            #[schema(inline)]
453            pub enabled: bool,
454            #[schema(inline)]
455            pub seconds: u64,
456        },
457
458        #[schema(inline)]
459        pub auto_start_behavior: ServerAutoStartBehavior,
460    }
461}
462
463#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
464pub enum ServerPowerAction {
465    #[serde(rename = "start")]
466    Start,
467    #[serde(rename = "stop")]
468    Stop,
469    #[serde(rename = "restart")]
470    Restart,
471    #[serde(rename = "kill")]
472    Kill,
473}
474
475#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
476pub enum ServerState {
477    #[serde(rename = "offline")]
478    Offline,
479    #[serde(rename = "starting")]
480    Starting,
481    #[serde(rename = "stopping")]
482    Stopping,
483    #[serde(rename = "running")]
484    Running,
485}
486
487#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
488pub enum StreamableArchiveFormat {
489    #[serde(rename = "tar")]
490    Tar,
491    #[serde(rename = "tar_gz")]
492    TarGz,
493    #[serde(rename = "tar_xz")]
494    TarXz,
495    #[serde(rename = "tar_lzip")]
496    TarLzip,
497    #[serde(rename = "tar_bz2")]
498    TarBz2,
499    #[serde(rename = "tar_lz4")]
500    TarLz4,
501    #[serde(rename = "tar_zstd")]
502    TarZstd,
503    #[serde(rename = "itaf")]
504    Itaf,
505    #[serde(rename = "itaf_gz")]
506    ItafGz,
507    #[serde(rename = "itaf_xz")]
508    ItafXz,
509    #[serde(rename = "itaf_lzip")]
510    ItafLzip,
511    #[serde(rename = "itaf_bz2")]
512    ItafBz2,
513    #[serde(rename = "itaf_lz4")]
514    ItafLz4,
515    #[serde(rename = "itaf_zstd")]
516    ItafZstd,
517    #[serde(rename = "zip")]
518    Zip,
519}
520
521#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
522pub enum SystemBackupsDdupBakCompressionFormat {
523    #[serde(rename = "none")]
524    None,
525    #[serde(rename = "deflate")]
526    Deflate,
527    #[serde(rename = "gzip")]
528    Gzip,
529    #[serde(rename = "brotli")]
530    Brotli,
531}
532
533pub type SystemPath = compact_str::CompactString;
534
535nestify::nest! {
536    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct SystemStats {
537        #[schema(inline)]
538        pub cpu: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct SystemStatsCpu {
539            #[schema(inline)]
540            pub used: f64,
541            #[schema(inline)]
542            pub threads: u64,
543            #[schema(inline)]
544            pub model: compact_str::CompactString,
545        },
546
547        #[schema(inline)]
548        pub network: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct SystemStatsNetwork {
549            #[schema(inline)]
550            pub received: u64,
551            #[schema(inline)]
552            pub received_packets: u64,
553            #[schema(inline)]
554            pub receiving_rate: f64,
555            #[schema(inline)]
556            pub received_packets_rate: f64,
557            #[schema(inline)]
558            pub sent: u64,
559            #[schema(inline)]
560            pub sent_packets: u64,
561            #[schema(inline)]
562            pub sending_rate: f64,
563            #[schema(inline)]
564            pub sending_packets_rate: f64,
565        },
566
567        #[schema(inline)]
568        pub memory: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct SystemStatsMemory {
569            #[schema(inline)]
570            pub used: u64,
571            #[schema(inline)]
572            pub used_process: u64,
573            #[schema(inline)]
574            pub total: u64,
575        },
576
577        #[schema(inline)]
578        pub disk: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct SystemStatsDisk {
579            #[schema(inline)]
580            pub used: u64,
581            #[schema(inline)]
582            pub total: u64,
583            #[schema(inline)]
584            pub read: u64,
585            #[schema(inline)]
586            pub reading_rate: f64,
587            #[schema(inline)]
588            pub written: u64,
589            #[schema(inline)]
590            pub writing_rate: f64,
591        },
592
593    }
594}
595
596#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
597pub enum TransferArchiveFormat {
598    #[serde(rename = "tar")]
599    Tar,
600    #[serde(rename = "tar_gz")]
601    TarGz,
602    #[serde(rename = "tar_xz")]
603    TarXz,
604    #[serde(rename = "tar_lzip")]
605    TarLzip,
606    #[serde(rename = "tar_bz2")]
607    TarBz2,
608    #[serde(rename = "tar_lz4")]
609    TarLz4,
610    #[serde(rename = "tar_zstd")]
611    TarZstd,
612    #[serde(rename = "itaf")]
613    Itaf,
614    #[serde(rename = "itaf_gz")]
615    ItafGz,
616    #[serde(rename = "itaf_xz")]
617    ItafXz,
618    #[serde(rename = "itaf_lzip")]
619    ItafLzip,
620    #[serde(rename = "itaf_bz2")]
621    ItafBz2,
622    #[serde(rename = "itaf_lz4")]
623    ItafLz4,
624    #[serde(rename = "itaf_zstd")]
625    ItafZstd,
626}
627
628nestify::nest! {
629    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct TransferCapabilities {
630        #[schema(inline)]
631        pub wings_archive_format: ArchiveFormat,
632        #[schema(inline)]
633        pub wings_archive_compression_level: CompressionLevel,
634        #[schema(inline)]
635        pub disk_limiter_mode: DiskLimiterMode,
636    }
637}
638
639nestify::nest! {
640    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct TransferProgress {
641        #[schema(inline)]
642        pub archive_bytes_processed: u64,
643        #[schema(inline)]
644        pub network_bytes_processed: u64,
645        #[schema(inline)]
646        pub bytes_total: u64,
647        #[schema(inline)]
648        pub files_processed: u64,
649    }
650}
651
652nestify::nest! {
653    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct UsedPort {
654        #[schema(inline)]
655        pub port: u32,
656        #[schema(inline)]
657        pub server: Option<uuid::Uuid>,
658    }
659}
660
661#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
662pub enum WebsocketEvent {
663    #[serde(rename = "auth success")]
664    AuthSuccess,
665    #[serde(rename = "token expiring")]
666    TokenExpiring,
667    #[serde(rename = "token expired")]
668    TokenExpired,
669    #[serde(rename = "auth")]
670    Auth,
671    #[serde(rename = "configure socket")]
672    ConfigureSocket,
673    #[serde(rename = "set state")]
674    SetState,
675    #[serde(rename = "send logs")]
676    SendLogs,
677    #[serde(rename = "send command")]
678    SendCommand,
679    #[serde(rename = "send stats")]
680    SendStats,
681    #[serde(rename = "send status")]
682    SendStatus,
683    #[serde(rename = "daemon error")]
684    DaemonError,
685    #[serde(rename = "jwt error")]
686    JwtError,
687    #[serde(rename = "ping")]
688    Ping,
689    #[serde(rename = "pong")]
690    Pong,
691    #[serde(rename = "stats")]
692    Stats,
693    #[serde(rename = "status")]
694    Status,
695    #[serde(rename = "pending restart")]
696    PendingRestart,
697    #[serde(rename = "custom event")]
698    CustomEvent,
699    #[serde(rename = "console output")]
700    ConsoleOutput,
701    #[serde(rename = "install output")]
702    InstallOutput,
703    #[serde(rename = "image pull progress")]
704    ImagePullProgress,
705    #[serde(rename = "image pull completed")]
706    ImagePullCompleted,
707    #[serde(rename = "install started")]
708    InstallStarted,
709    #[serde(rename = "install progress")]
710    InstallProgress,
711    #[serde(rename = "install completed")]
712    InstallCompleted,
713    #[serde(rename = "daemon message")]
714    DaemonMessage,
715    #[serde(rename = "backup started")]
716    BackupStarted,
717    #[serde(rename = "backup progress")]
718    BackupProgress,
719    #[serde(rename = "backup completed")]
720    BackupCompleted,
721    #[serde(rename = "backup deleted")]
722    BackupDeleted,
723    #[serde(rename = "backup restore started")]
724    BackupRestoreStarted,
725    #[serde(rename = "backup restore progress")]
726    BackupRestoreProgress,
727    #[serde(rename = "backup restore completed")]
728    BackupRestoreCompleted,
729    #[serde(rename = "transfer logs")]
730    TransferLogs,
731    #[serde(rename = "transfer status")]
732    TransferStatus,
733    #[serde(rename = "transfer progress")]
734    TransferProgress,
735    #[serde(rename = "schedule started")]
736    ScheduleStarted,
737    #[serde(rename = "schedule step status")]
738    ScheduleStepStatus,
739    #[serde(rename = "schedule step error")]
740    ScheduleStepError,
741    #[serde(rename = "schedule completed")]
742    ScheduleCompleted,
743    #[serde(rename = "operation progress")]
744    OperationProgress,
745    #[serde(rename = "operation error")]
746    OperationError,
747    #[serde(rename = "operation completed")]
748    OperationCompleted,
749    #[serde(rename = "operation aborted")]
750    OperationAborted,
751    #[serde(rename = "file collab subscribe")]
752    FileCollabSubscribe,
753    #[serde(rename = "file collab unsubscribe")]
754    FileCollabUnsubscribe,
755    #[serde(rename = "file collab update")]
756    FileCollabUpdate,
757    #[serde(rename = "file collab awareness")]
758    FileCollabAwareness,
759    #[serde(rename = "file collab save")]
760    FileCollabSave,
761    #[serde(rename = "file collab sync")]
762    FileCollabSync,
763    #[serde(rename = "file collab participants")]
764    FileCollabParticipants,
765    #[serde(rename = "file collab saved")]
766    FileCollabSaved,
767    #[serde(rename = "file collab reload")]
768    FileCollabReload,
769    #[serde(rename = "file collab conflict")]
770    FileCollabConflict,
771    #[serde(rename = "file collab error")]
772    FileCollabError,
773}
774
775nestify::nest! {
776    #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct WebsocketMessage {
777        #[schema(inline)]
778        pub event: WebsocketEvent,
779        #[schema(inline)]
780        pub args: Vec<compact_str::CompactString>,
781    }
782}
783
784pub mod backups_backup {
785    use super::*;
786
787    pub mod delete {
788        use super::*;
789
790        nestify::nest! {
791            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
792                #[schema(inline)]
793                pub adapter: BackupAdapter,
794                #[schema(inline)]
795                pub foreground: bool,
796                #[schema(inline)]
797                pub server: Option<uuid::Uuid>,
798            }
799        }
800
801        nestify::nest! {
802            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
803            }
804        }
805
806        nestify::nest! {
807            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
808            }
809        }
810
811        pub type Response404 = ApiError;
812
813        #[derive(Deserialize)]
814        #[serde(untagged)]
815        pub enum Response {
816            Ok(Response200),
817            Accepted(Response202),
818        }
819    }
820}
821pub mod backups_backup_export {
822    use super::*;
823
824    pub mod post {
825        use super::*;
826
827        nestify::nest! {
828            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
829                #[schema(inline)]
830                pub adapter: BackupAdapter,
831                #[schema(inline)]
832                pub server: uuid::Uuid,
833                #[schema(inline)]
834                pub path: compact_str::CompactString,
835                #[schema(inline)]
836                pub archive_format: StreamableArchiveFormat,
837                #[schema(inline)]
838                pub foreground: bool,
839            }
840        }
841
842        pub type Response200 = DirectoryEntry;
843
844        nestify::nest! {
845            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
846                #[schema(inline)]
847                pub identifier: uuid::Uuid,
848            }
849        }
850
851        pub type Response404 = ApiError;
852
853        pub type Response417 = ApiError;
854
855        #[derive(Deserialize)]
856        #[serde(untagged)]
857        pub enum Response {
858            Ok(Response200),
859            Accepted(Response202),
860        }
861    }
862}
863pub mod backups_backup_query {
864    use super::*;
865
866    pub mod get {
867        use super::*;
868
869        nestify::nest! {
870            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
871                #[schema(inline)]
872                pub archive_format: Option<ArchiveFormat>,
873                #[schema(inline)]
874                pub size: Option<u64>,
875            }
876        }
877
878        pub type Response404 = ApiError;
879
880        pub type Response = Response200;
881
882        #[derive(Debug, Clone, Default)]
883        #[allow(clippy::manual_non_exhaustive)]
884        pub struct Query {
885            pub adapter: Option<BackupAdapter>,
886            #[doc(hidden)]
887            pub __priv: (),
888        }
889    }
890}
891pub mod deauthorize_user {
892    use super::*;
893
894    pub mod post {
895        use super::*;
896
897        nestify::nest! {
898            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
899                #[schema(inline)]
900                pub servers: Vec<uuid::Uuid>,
901                #[schema(inline)]
902                pub user: uuid::Uuid,
903            }
904        }
905
906        nestify::nest! {
907            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
908            }
909        }
910
911        nestify::nest! {
912            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response409 {
913                #[schema(inline)]
914                pub error: compact_str::CompactString,
915            }
916        }
917
918        pub type Response = Response200;
919    }
920}
921pub mod ports_used {
922    use super::*;
923
924    pub mod get {
925        use super::*;
926
927        nestify::nest! {
928            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
929                #[schema(inline)]
930                pub used: IndexMap<compact_str::CompactString, Vec<UsedPort>>,
931            }
932        }
933
934        nestify::nest! {
935            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response400 {
936                #[schema(inline)]
937                pub error: compact_str::CompactString,
938            }
939        }
940
941        pub type Response = Response200;
942
943        #[derive(Debug, Clone, Default)]
944        #[allow(clippy::manual_non_exhaustive)]
945        pub struct Query {
946            pub ip: Option<Vec<compact_str::CompactString>>,
947            #[doc(hidden)]
948            pub __priv: (),
949        }
950    }
951}
952pub mod servers {
953    use super::*;
954
955    pub mod get {
956        use super::*;
957
958        pub type Response200 = Vec<Server>;
959
960        pub type Response = Response200;
961    }
962
963    pub mod post {
964        use super::*;
965
966        nestify::nest! {
967            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
968                #[schema(inline)]
969                pub uuid: uuid::Uuid,
970                #[schema(inline)]
971                pub start_on_completion: bool,
972                #[schema(inline)]
973                pub skip_scripts: bool,
974            }
975        }
976
977        nestify::nest! {
978            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
979            }
980        }
981
982        pub type Response409 = ApiError;
983
984        pub type Response = Response200;
985    }
986}
987pub mod servers_power {
988    use super::*;
989
990    pub mod post {
991        use super::*;
992
993        nestify::nest! {
994            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
995                #[schema(inline)]
996                pub servers: ServerSelector,
997                #[schema(inline)]
998                pub action: ServerPowerAction,
999                #[schema(inline)]
1000                pub wait_seconds: Option<u64>,
1001            }
1002        }
1003
1004        nestify::nest! {
1005            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1006                #[schema(inline)]
1007                pub affected: u64,
1008            }
1009        }
1010
1011        pub type Response = Response202;
1012    }
1013}
1014pub mod servers_utilization {
1015    use super::*;
1016
1017    pub mod get {
1018        use super::*;
1019
1020        type Response200 = IndexMap<uuid::Uuid, ResourceUsage>;
1021        pub type Response404 = ApiError;
1022
1023        pub type Response = Response200;
1024    }
1025}
1026pub mod servers_server {
1027    use super::*;
1028
1029    pub mod get {
1030        use super::*;
1031
1032        pub type Response200 = Server;
1033
1034        pub type Response = Response200;
1035    }
1036
1037    pub mod delete {
1038        use super::*;
1039
1040        nestify::nest! {
1041            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1042            }
1043        }
1044
1045        pub type Response = Response200;
1046    }
1047}
1048pub mod servers_server_backup {
1049    use super::*;
1050
1051    pub mod post {
1052        use super::*;
1053
1054        nestify::nest! {
1055            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1056                #[schema(inline)]
1057                pub adapter: BackupAdapter,
1058                #[schema(inline)]
1059                pub uuid: uuid::Uuid,
1060                #[schema(inline)]
1061                pub ignore: compact_str::CompactString,
1062            }
1063        }
1064
1065        nestify::nest! {
1066            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1067            }
1068        }
1069
1070        pub type Response409 = ApiError;
1071
1072        pub type Response = Response202;
1073    }
1074}
1075pub mod servers_server_backup_backup {
1076    use super::*;
1077
1078    pub mod delete {
1079        use super::*;
1080
1081        nestify::nest! {
1082            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1083            }
1084        }
1085
1086        pub type Response404 = ApiError;
1087
1088        pub type Response = Response202;
1089    }
1090}
1091pub mod servers_server_backup_backup_restore {
1092    use super::*;
1093
1094    pub mod post {
1095        use super::*;
1096
1097        nestify::nest! {
1098            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1099                #[schema(inline)]
1100                pub adapter: BackupAdapter,
1101                #[schema(inline)]
1102                pub truncate_directory: bool,
1103                #[schema(inline)]
1104                pub download_url: Option<compact_str::CompactString>,
1105            }
1106        }
1107
1108        nestify::nest! {
1109            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1110            }
1111        }
1112
1113        pub type Response404 = ApiError;
1114
1115        pub type Response = Response202;
1116    }
1117}
1118pub mod servers_server_commands {
1119    use super::*;
1120
1121    pub mod post {
1122        use super::*;
1123
1124        nestify::nest! {
1125            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1126                #[schema(inline)]
1127                pub commands: Vec<compact_str::CompactString>,
1128            }
1129        }
1130
1131        nestify::nest! {
1132            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1133            }
1134        }
1135
1136        pub type Response417 = ApiError;
1137
1138        pub type Response = Response200;
1139    }
1140}
1141pub mod servers_server_files_chmod {
1142    use super::*;
1143
1144    pub mod post {
1145        use super::*;
1146
1147        nestify::nest! {
1148            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1149                #[schema(inline)]
1150                pub root: compact_str::CompactString,
1151                #[schema(inline)]
1152                pub files: Vec<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodyFiles {
1153                    #[schema(inline)]
1154                    pub file: compact_str::CompactString,
1155                    #[schema(inline)]
1156                    pub mode: compact_str::CompactString,
1157                    #[schema(inline)]
1158                    pub recursive: bool,
1159                }>,
1160            }
1161        }
1162
1163        nestify::nest! {
1164            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1165                #[schema(inline)]
1166                pub updated: u64,
1167            }
1168        }
1169
1170        pub type Response404 = ApiError;
1171
1172        pub type Response417 = ApiError;
1173
1174        pub type Response = Response200;
1175    }
1176}
1177pub mod servers_server_files_compress {
1178    use super::*;
1179
1180    pub mod post {
1181        use super::*;
1182
1183        nestify::nest! {
1184            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1185                #[schema(inline)]
1186                pub format: ArchiveFormat,
1187                #[schema(inline)]
1188                pub name: Option<compact_str::CompactString>,
1189                #[schema(inline)]
1190                pub root: compact_str::CompactString,
1191                #[schema(inline)]
1192                pub files: Vec<compact_str::CompactString>,
1193                #[schema(inline)]
1194                pub foreground: bool,
1195            }
1196        }
1197
1198        pub type Response200 = DirectoryEntry;
1199
1200        nestify::nest! {
1201            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1202                #[schema(inline)]
1203                pub identifier: uuid::Uuid,
1204            }
1205        }
1206
1207        pub type Response404 = ApiError;
1208
1209        pub type Response417 = ApiError;
1210
1211        #[derive(Deserialize)]
1212        #[serde(untagged)]
1213        pub enum Response {
1214            Ok(Response200),
1215            Accepted(Response202),
1216        }
1217    }
1218}
1219pub mod servers_server_files_contents {
1220    use super::*;
1221
1222    pub mod get {
1223        use super::*;
1224
1225        pub type Response200 = AsyncResponseReader;
1226
1227        pub type Response404 = ApiError;
1228
1229        pub type Response413 = ApiError;
1230
1231        pub type Response417 = ApiError;
1232
1233        pub type Response = Response200;
1234
1235        #[derive(Debug, Clone, Default)]
1236        #[allow(clippy::manual_non_exhaustive)]
1237        pub struct Query {
1238            pub file: Option<compact_str::CompactString>,
1239            pub download: Option<bool>,
1240            pub max_size: Option<u64>,
1241            #[doc(hidden)]
1242            pub __priv: (),
1243        }
1244    }
1245}
1246pub mod servers_server_files_copy {
1247    use super::*;
1248
1249    pub mod post {
1250        use super::*;
1251
1252        nestify::nest! {
1253            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1254                #[schema(inline)]
1255                pub path: compact_str::CompactString,
1256                #[schema(inline)]
1257                pub name: Option<compact_str::CompactString>,
1258                #[schema(inline)]
1259                pub overwrite: bool,
1260                #[schema(inline)]
1261                pub foreground: bool,
1262            }
1263        }
1264
1265        pub type Response200 = DirectoryEntry;
1266
1267        nestify::nest! {
1268            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1269                #[schema(inline)]
1270                pub identifier: uuid::Uuid,
1271            }
1272        }
1273
1274        pub type Response404 = ApiError;
1275
1276        pub type Response409 = ApiError;
1277
1278        pub type Response417 = ApiError;
1279
1280        #[derive(Deserialize)]
1281        #[serde(untagged)]
1282        pub enum Response {
1283            Ok(Response200),
1284            Accepted(Response202),
1285        }
1286    }
1287}
1288pub mod servers_server_files_copy_many {
1289    use super::*;
1290
1291    pub mod post {
1292        use super::*;
1293
1294        nestify::nest! {
1295            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1296                #[schema(inline)]
1297                pub root: compact_str::CompactString,
1298                #[schema(inline)]
1299                pub files: Vec<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodyFiles {
1300                    #[schema(inline)]
1301                    pub from: compact_str::CompactString,
1302                    #[schema(inline)]
1303                    pub to: compact_str::CompactString,
1304                }>,
1305                #[schema(inline)]
1306                pub overwrite: bool,
1307                #[schema(inline)]
1308                pub foreground: bool,
1309            }
1310        }
1311
1312        nestify::nest! {
1313            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1314                #[schema(inline)]
1315                pub copied: u64,
1316                #[schema(inline)]
1317                pub skipped: Vec<DirectoryEntry>,
1318            }
1319        }
1320
1321        nestify::nest! {
1322            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1323                #[schema(inline)]
1324                pub identifier: uuid::Uuid,
1325                #[schema(inline)]
1326                pub skipped: Vec<DirectoryEntry>,
1327            }
1328        }
1329
1330        pub type Response404 = ApiError;
1331
1332        pub type Response417 = ApiError;
1333
1334        #[derive(Deserialize)]
1335        #[serde(untagged)]
1336        pub enum Response {
1337            Ok(Response200),
1338            Accepted(Response202),
1339        }
1340    }
1341}
1342pub mod servers_server_files_copy_remote {
1343    use super::*;
1344
1345    pub mod post {
1346        use super::*;
1347
1348        nestify::nest! {
1349            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1350                #[schema(inline)]
1351                pub url: compact_str::CompactString,
1352                #[schema(inline)]
1353                pub token: compact_str::CompactString,
1354                #[schema(inline)]
1355                pub archive_format: TransferArchiveFormat,
1356                #[schema(inline)]
1357                pub compression_level: Option<CompressionLevel>,
1358                #[schema(inline)]
1359                pub root: compact_str::CompactString,
1360                #[schema(inline)]
1361                pub files: Vec<CopyFile>,
1362                #[schema(inline)]
1363                pub destination_server: uuid::Uuid,
1364                #[schema(inline)]
1365                pub destination_path: compact_str::CompactString,
1366                #[schema(inline)]
1367                pub foreground: bool,
1368            }
1369        }
1370
1371        nestify::nest! {
1372            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1373            }
1374        }
1375
1376        nestify::nest! {
1377            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1378                #[schema(inline)]
1379                pub identifier: uuid::Uuid,
1380            }
1381        }
1382
1383        pub type Response404 = ApiError;
1384
1385        pub type Response417 = ApiError;
1386
1387        #[derive(Deserialize)]
1388        #[serde(untagged)]
1389        pub enum Response {
1390            Ok(Response200),
1391            Accepted(Response202),
1392        }
1393    }
1394}
1395pub mod servers_server_files_create_directory {
1396    use super::*;
1397
1398    pub mod post {
1399        use super::*;
1400
1401        nestify::nest! {
1402            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1403                #[schema(inline)]
1404                pub root: compact_str::CompactString,
1405                #[schema(inline)]
1406                pub name: compact_str::CompactString,
1407            }
1408        }
1409
1410        nestify::nest! {
1411            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1412            }
1413        }
1414
1415        pub type Response404 = ApiError;
1416
1417        pub type Response417 = ApiError;
1418
1419        pub type Response = Response200;
1420    }
1421}
1422pub mod servers_server_files_create_symlink {
1423    use super::*;
1424
1425    pub mod post {
1426        use super::*;
1427
1428        nestify::nest! {
1429            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1430                #[schema(inline)]
1431                pub root: compact_str::CompactString,
1432                #[schema(inline)]
1433                pub link: compact_str::CompactString,
1434                #[schema(inline)]
1435                pub target: compact_str::CompactString,
1436            }
1437        }
1438
1439        nestify::nest! {
1440            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1441            }
1442        }
1443
1444        pub type Response404 = ApiError;
1445
1446        pub type Response417 = ApiError;
1447
1448        pub type Response = Response200;
1449    }
1450}
1451pub mod servers_server_files_decompress {
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 root: compact_str::CompactString,
1461                #[schema(inline)]
1462                pub file: compact_str::CompactString,
1463                #[schema(inline)]
1464                pub foreground: bool,
1465            }
1466        }
1467
1468        nestify::nest! {
1469            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1470            }
1471        }
1472
1473        nestify::nest! {
1474            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1475                #[schema(inline)]
1476                pub identifier: uuid::Uuid,
1477            }
1478        }
1479
1480        pub type Response404 = ApiError;
1481
1482        pub type Response417 = ApiError;
1483
1484        #[derive(Deserialize)]
1485        #[serde(untagged)]
1486        pub enum Response {
1487            Ok(Response200),
1488            Accepted(Response202),
1489        }
1490    }
1491}
1492pub mod servers_server_files_delete {
1493    use super::*;
1494
1495    pub mod post {
1496        use super::*;
1497
1498        nestify::nest! {
1499            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1500                #[schema(inline)]
1501                pub root: compact_str::CompactString,
1502                #[schema(inline)]
1503                pub files: Vec<compact_str::CompactString>,
1504            }
1505        }
1506
1507        nestify::nest! {
1508            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1509                #[schema(inline)]
1510                pub deleted: u64,
1511            }
1512        }
1513
1514        pub type Response404 = ApiError;
1515
1516        pub type Response417 = ApiError;
1517
1518        pub type Response = Response200;
1519    }
1520}
1521pub mod servers_server_files_fingerprints {
1522    use super::*;
1523
1524    pub mod get {
1525        use super::*;
1526
1527        nestify::nest! {
1528            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1529                #[schema(inline)]
1530                pub fingerprints: IndexMap<compact_str::CompactString, compact_str::CompactString>,
1531            }
1532        }
1533
1534        pub type Response = Response200;
1535
1536        #[derive(Debug, Clone, Default)]
1537        #[allow(clippy::manual_non_exhaustive)]
1538        pub struct Query {
1539            pub algorithm: Option<Algorithm>,
1540            pub files: Option<Vec<compact_str::CompactString>>,
1541            #[doc(hidden)]
1542            pub __priv: (),
1543        }
1544    }
1545}
1546pub mod servers_server_files_largest_directories {
1547    use super::*;
1548
1549    pub mod get {
1550        use super::*;
1551
1552        pub type Response200 = Vec<DirectoryEntry>;
1553
1554        pub type Response404 = ApiError;
1555
1556        pub type Response417 = ApiError;
1557
1558        pub type Response = Response200;
1559
1560        #[derive(Debug, Clone, Default)]
1561        #[allow(clippy::manual_non_exhaustive)]
1562        pub struct Query {
1563            pub directory: Option<compact_str::CompactString>,
1564            pub ignored: Option<Vec<compact_str::CompactString>>,
1565            #[doc(hidden)]
1566            pub __priv: (),
1567        }
1568    }
1569}
1570pub mod servers_server_files_list {
1571    use super::*;
1572
1573    pub mod get {
1574        use super::*;
1575
1576        nestify::nest! {
1577            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1578                #[schema(inline)]
1579                pub total: u64,
1580                #[schema(inline)]
1581                pub filesystem_primary: bool,
1582                #[schema(inline)]
1583                pub filesystem_writable: bool,
1584                #[schema(inline)]
1585                pub filesystem_fast: bool,
1586                #[schema(inline)]
1587                pub entries: Vec<DirectoryEntry>,
1588            }
1589        }
1590
1591        pub type Response404 = ApiError;
1592
1593        pub type Response417 = ApiError;
1594
1595        pub type Response = Response200;
1596
1597        #[derive(Debug, Clone, Default)]
1598        #[allow(clippy::manual_non_exhaustive)]
1599        pub struct Query {
1600            pub directory: Option<compact_str::CompactString>,
1601            pub ignored: Option<Vec<compact_str::CompactString>>,
1602            pub per_page: Option<u64>,
1603            pub page: Option<u64>,
1604            pub sort: Option<DirectorySortingMode>,
1605            #[doc(hidden)]
1606            pub __priv: (),
1607        }
1608    }
1609}
1610pub mod servers_server_files_list_directory {
1611    use super::*;
1612
1613    pub mod get {
1614        use super::*;
1615
1616        pub type Response200 = Vec<DirectoryEntry>;
1617
1618        pub type Response404 = ApiError;
1619
1620        pub type Response417 = ApiError;
1621
1622        pub type Response = Response200;
1623
1624        #[derive(Debug, Clone, Default)]
1625        #[allow(clippy::manual_non_exhaustive)]
1626        pub struct Query {
1627            pub directory: Option<compact_str::CompactString>,
1628            #[doc(hidden)]
1629            pub __priv: (),
1630        }
1631    }
1632}
1633pub mod servers_server_files_operations {
1634    use super::*;
1635
1636    pub mod get {
1637        use super::*;
1638
1639        nestify::nest! {
1640            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1641                #[schema(inline)]
1642                pub operations: Vec<FilesystemOperation>,
1643            }
1644        }
1645
1646        pub type Response = Response200;
1647    }
1648}
1649pub mod servers_server_files_operations_operation {
1650    use super::*;
1651
1652    pub mod delete {
1653        use super::*;
1654
1655        nestify::nest! {
1656            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1657            }
1658        }
1659
1660        pub type Response404 = ApiError;
1661
1662        pub type Response = Response200;
1663    }
1664}
1665pub mod servers_server_files_pull {
1666    use super::*;
1667
1668    pub mod get {
1669        use super::*;
1670
1671        nestify::nest! {
1672            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1673                #[schema(inline)]
1674                pub downloads: Vec<Download>,
1675            }
1676        }
1677
1678        pub type Response = Response200;
1679    }
1680
1681    pub mod post {
1682        use super::*;
1683
1684        nestify::nest! {
1685            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1686                #[schema(inline)]
1687                pub root: compact_str::CompactString,
1688                #[schema(inline)]
1689                pub url: compact_str::CompactString,
1690                #[schema(inline)]
1691                pub file_name: Option<compact_str::CompactString>,
1692                #[schema(inline)]
1693                pub use_header: bool,
1694                #[schema(inline)]
1695                pub foreground: bool,
1696            }
1697        }
1698
1699        nestify::nest! {
1700            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1701            }
1702        }
1703
1704        nestify::nest! {
1705            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1706                #[schema(inline)]
1707                pub identifier: uuid::Uuid,
1708            }
1709        }
1710
1711        pub type Response417 = ApiError;
1712
1713        #[derive(Deserialize)]
1714        #[serde(untagged)]
1715        pub enum Response {
1716            Ok(Response200),
1717            Accepted(Response202),
1718        }
1719    }
1720}
1721pub mod servers_server_files_pull_query {
1722    use super::*;
1723
1724    pub mod post {
1725        use super::*;
1726
1727        nestify::nest! {
1728            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1729                #[schema(inline)]
1730                pub url: compact_str::CompactString,
1731            }
1732        }
1733
1734        nestify::nest! {
1735            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1736                #[schema(inline)]
1737                pub file_name: Option<compact_str::CompactString>,
1738                #[schema(inline)]
1739                pub file_size: Option<u64>,
1740                #[schema(inline)]
1741                pub final_url: compact_str::CompactString,
1742                #[schema(inline)]
1743                pub headers: IndexMap<compact_str::CompactString, compact_str::CompactString>,
1744            }
1745        }
1746
1747        pub type Response417 = ApiError;
1748
1749        pub type Response = Response200;
1750    }
1751}
1752pub mod servers_server_files_pull_pull {
1753    use super::*;
1754
1755    pub mod delete {
1756        use super::*;
1757
1758        nestify::nest! {
1759            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1760            }
1761        }
1762
1763        pub type Response404 = ApiError;
1764
1765        pub type Response = Response200;
1766    }
1767}
1768pub mod servers_server_files_rename {
1769    use super::*;
1770
1771    pub mod put {
1772        use super::*;
1773
1774        nestify::nest! {
1775            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1776                #[schema(inline)]
1777                pub root: compact_str::CompactString,
1778                #[schema(inline)]
1779                pub files: Vec<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodyFiles {
1780                    #[schema(inline)]
1781                    pub from: compact_str::CompactString,
1782                    #[schema(inline)]
1783                    pub to: compact_str::CompactString,
1784                }>,
1785            }
1786        }
1787
1788        nestify::nest! {
1789            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1790                #[schema(inline)]
1791                pub renamed: u64,
1792            }
1793        }
1794
1795        pub type Response404 = ApiError;
1796
1797        pub type Response = Response200;
1798    }
1799}
1800pub mod servers_server_files_revisions {
1801    use super::*;
1802
1803    pub mod get {
1804        use super::*;
1805
1806        nestify::nest! {
1807            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1808                #[schema(inline)]
1809                pub revisions: Vec<RevisionInfo>,
1810            }
1811        }
1812
1813        pub type Response = Response200;
1814
1815        #[derive(Debug, Clone, Default)]
1816        #[allow(clippy::manual_non_exhaustive)]
1817        pub struct Query {
1818            pub file: Option<compact_str::CompactString>,
1819            #[doc(hidden)]
1820            pub __priv: (),
1821        }
1822    }
1823}
1824pub mod servers_server_files_revisions_revision {
1825    use super::*;
1826
1827    pub mod get {
1828        use super::*;
1829
1830        pub type Response200 = AsyncResponseReader;
1831
1832        pub type Response404 = ApiError;
1833
1834        pub type Response = Response200;
1835
1836        #[derive(Debug, Clone, Default)]
1837        #[allow(clippy::manual_non_exhaustive)]
1838        pub struct Query {
1839            pub file: Option<compact_str::CompactString>,
1840            #[doc(hidden)]
1841            pub __priv: (),
1842        }
1843    }
1844}
1845pub mod servers_server_files_search {
1846    use super::*;
1847
1848    pub mod post {
1849        use super::*;
1850
1851        nestify::nest! {
1852            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1853                #[schema(inline)]
1854                pub root: compact_str::CompactString,
1855                #[schema(inline)]
1856                pub path_filter: Option<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodyPathFilter {
1857                    #[schema(inline)]
1858                    pub include: Vec<compact_str::CompactString>,
1859                    #[schema(inline)]
1860                    pub exclude: Vec<compact_str::CompactString>,
1861                    #[schema(inline)]
1862                    pub case_insensitive: bool,
1863                }>,
1864                #[schema(inline)]
1865                pub size_filter: Option<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodySizeFilter {
1866                    #[schema(inline)]
1867                    pub min: u64,
1868                    #[schema(inline)]
1869                    pub max: u64,
1870                }>,
1871                #[schema(inline)]
1872                pub content_filter: Option<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodyContentFilter {
1873                    #[schema(inline)]
1874                    pub query: compact_str::CompactString,
1875                    #[schema(inline)]
1876                    pub max_search_size: u64,
1877                    #[schema(inline)]
1878                    pub include_unmatched: bool,
1879                    #[schema(inline)]
1880                    pub case_insensitive: bool,
1881                }>,
1882                #[schema(inline)]
1883                pub per_page: u64,
1884            }
1885        }
1886
1887        nestify::nest! {
1888            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1889                #[schema(inline)]
1890                pub results: Vec<DirectoryEntry>,
1891            }
1892        }
1893
1894        pub type Response404 = ApiError;
1895
1896        pub type Response = Response200;
1897    }
1898}
1899pub mod servers_server_files_sqlite_query {
1900    use super::*;
1901
1902    pub mod post {
1903        use super::*;
1904
1905        nestify::nest! {
1906            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
1907                #[schema(inline)]
1908                pub file: compact_str::CompactString,
1909                #[schema(inline)]
1910                pub query: compact_str::CompactString,
1911                #[schema(inline)]
1912                pub read_only: bool,
1913                #[schema(inline)]
1914                pub rows: u32,
1915            }
1916        }
1917
1918        nestify::nest! {
1919            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1920                #[schema(inline)]
1921                pub results: Vec<QueryResultSet>,
1922            }
1923        }
1924
1925        pub type Response400 = ApiError;
1926
1927        pub type Response404 = ApiError;
1928
1929        pub type Response408 = ApiError;
1930
1931        pub type Response417 = ApiError;
1932
1933        pub type Response = Response200;
1934    }
1935}
1936pub mod servers_server_files_write {
1937    use super::*;
1938
1939    pub mod post {
1940        use super::*;
1941
1942        pub type RequestBody = AsyncRequestReader;
1943
1944        nestify::nest! {
1945            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
1946                #[schema(inline)]
1947                pub revision_id: Option<i64>,
1948            }
1949        }
1950
1951        pub type Response404 = ApiError;
1952
1953        pub type Response417 = ApiError;
1954
1955        pub type Response = Response200;
1956
1957        #[derive(Debug, Clone, Default)]
1958        #[allow(clippy::manual_non_exhaustive)]
1959        pub struct Query {
1960            pub file: Option<compact_str::CompactString>,
1961            pub user: Option<uuid::Uuid>,
1962            #[doc(hidden)]
1963            pub __priv: (),
1964        }
1965    }
1966}
1967pub mod servers_server_install_abort {
1968    use super::*;
1969
1970    pub mod post {
1971        use super::*;
1972
1973        nestify::nest! {
1974            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
1975            }
1976        }
1977
1978        pub type Response409 = ApiError;
1979
1980        pub type Response = Response202;
1981    }
1982}
1983pub mod servers_server_logs {
1984    use super::*;
1985
1986    pub mod get {
1987        use super::*;
1988
1989        pub type Response200 = AsyncResponseReader;
1990
1991        pub type Response = Response200;
1992
1993        #[derive(Debug, Clone, Default)]
1994        #[allow(clippy::manual_non_exhaustive)]
1995        pub struct Query {
1996            pub lines: Option<u64>,
1997            #[doc(hidden)]
1998            pub __priv: (),
1999        }
2000    }
2001}
2002pub mod servers_server_logs_install {
2003    use super::*;
2004
2005    pub mod get {
2006        use super::*;
2007
2008        pub type Response200 = AsyncResponseReader;
2009
2010        pub type Response404 = ApiError;
2011
2012        pub type Response = Response200;
2013
2014        #[derive(Debug, Clone, Default)]
2015        #[allow(clippy::manual_non_exhaustive)]
2016        pub struct Query {
2017            pub lines: Option<u64>,
2018            #[doc(hidden)]
2019            pub __priv: (),
2020        }
2021    }
2022}
2023pub mod servers_server_power {
2024    use super::*;
2025
2026    pub mod post {
2027        use super::*;
2028
2029        nestify::nest! {
2030            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
2031                #[schema(inline)]
2032                pub action: ServerPowerAction,
2033                #[schema(inline)]
2034                pub wait_seconds: Option<u64>,
2035            }
2036        }
2037
2038        nestify::nest! {
2039            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
2040            }
2041        }
2042
2043        pub type Response = Response202;
2044    }
2045}
2046pub mod servers_server_reinstall {
2047    use super::*;
2048
2049    pub mod post {
2050        use super::*;
2051
2052        nestify::nest! {
2053            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
2054                #[schema(inline)]
2055                pub truncate_directory: bool,
2056                #[schema(inline)]
2057                pub installation_script: Option<InstallationScript>,
2058            }
2059        }
2060
2061        nestify::nest! {
2062            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
2063            }
2064        }
2065
2066        pub type Response409 = ApiError;
2067
2068        pub type Response = Response202;
2069    }
2070}
2071pub mod servers_server_schedules_schedule {
2072    use super::*;
2073
2074    pub mod get {
2075        use super::*;
2076
2077        nestify::nest! {
2078            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2079                #[schema(inline)]
2080                pub status: ScheduleStatus,
2081            }
2082        }
2083
2084        pub type Response404 = ApiError;
2085
2086        pub type Response = Response200;
2087    }
2088}
2089pub mod servers_server_schedules_schedule_abort {
2090    use super::*;
2091
2092    pub mod post {
2093        use super::*;
2094
2095        nestify::nest! {
2096            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2097            }
2098        }
2099
2100        pub type Response404 = ApiError;
2101
2102        pub type Response = Response200;
2103    }
2104}
2105pub mod servers_server_schedules_schedule_trigger {
2106    use super::*;
2107
2108    pub mod post {
2109        use super::*;
2110
2111        nestify::nest! {
2112            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
2113                #[schema(inline)]
2114                pub skip_condition: bool,
2115            }
2116        }
2117
2118        nestify::nest! {
2119            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2120            }
2121        }
2122
2123        pub type Response404 = ApiError;
2124
2125        pub type Response = Response200;
2126    }
2127}
2128pub mod servers_server_script {
2129    use super::*;
2130
2131    pub mod post {
2132        use super::*;
2133
2134        pub type RequestBody = InstallationScript;
2135
2136        pub type Response200 = AsyncResponseReader;
2137
2138        pub type Response = Response200;
2139    }
2140}
2141pub mod servers_server_sync {
2142    use super::*;
2143
2144    pub mod post {
2145        use super::*;
2146
2147        nestify::nest! {
2148            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
2149                #[schema(inline)]
2150                pub server: serde_json::Value,
2151            }
2152        }
2153
2154        nestify::nest! {
2155            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2156            }
2157        }
2158
2159        pub type Response = Response200;
2160    }
2161}
2162pub mod servers_server_transfer {
2163    use super::*;
2164
2165    pub mod delete {
2166        use super::*;
2167
2168        nestify::nest! {
2169            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2170            }
2171        }
2172
2173        pub type Response417 = ApiError;
2174
2175        pub type Response = Response200;
2176    }
2177
2178    pub mod post {
2179        use super::*;
2180
2181        nestify::nest! {
2182            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
2183                #[schema(inline)]
2184                pub url: compact_str::CompactString,
2185                #[schema(inline)]
2186                pub token: compact_str::CompactString,
2187                #[schema(inline)]
2188                pub archive_format: TransferArchiveFormat,
2189                #[schema(inline)]
2190                pub compression_level: Option<CompressionLevel>,
2191                #[schema(inline)]
2192                pub backups: Vec<uuid::Uuid>,
2193                #[schema(inline)]
2194                pub delete_backups: bool,
2195                #[schema(inline)]
2196                pub multiplex_streams: u64,
2197            }
2198        }
2199
2200        nestify::nest! {
2201            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
2202            }
2203        }
2204
2205        pub type Response409 = ApiError;
2206
2207        pub type Response = Response202;
2208    }
2209}
2210pub mod servers_server_utilization {
2211    use super::*;
2212
2213    pub mod get {
2214        use super::*;
2215
2216        nestify::nest! {
2217            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2218                #[schema(inline)]
2219                pub utilization: ResourceUsage,
2220            }
2221        }
2222
2223        pub type Response404 = ApiError;
2224
2225        pub type Response = Response200;
2226    }
2227}
2228pub mod servers_server_version {
2229    use super::*;
2230
2231    pub mod get {
2232        use super::*;
2233
2234        nestify::nest! {
2235            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2236                #[schema(inline)]
2237                pub hash: compact_str::CompactString,
2238            }
2239        }
2240
2241        pub type Response404 = ApiError;
2242
2243        pub type Response = Response200;
2244
2245        #[derive(Debug, Clone, Default)]
2246        #[allow(clippy::manual_non_exhaustive)]
2247        pub struct Query {
2248            pub game: Option<Game>,
2249            #[doc(hidden)]
2250            pub __priv: (),
2251        }
2252    }
2253}
2254pub mod servers_server_ws_broadcast {
2255    use super::*;
2256
2257    pub mod post {
2258        use super::*;
2259
2260        nestify::nest! {
2261            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
2262                #[schema(inline)]
2263                pub users: Vec<uuid::Uuid>,
2264                #[schema(inline)]
2265                pub permissions: Vec<compact_str::CompactString>,
2266                #[schema(inline)]
2267                pub message: WebsocketMessage,
2268            }
2269        }
2270
2271        nestify::nest! {
2272            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2273            }
2274        }
2275
2276        pub type Response = Response200;
2277    }
2278}
2279pub mod servers_server_ws_deny {
2280    use super::*;
2281
2282    pub mod post {
2283        use super::*;
2284
2285        nestify::nest! {
2286            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
2287                #[schema(inline)]
2288                pub jtis: Vec<compact_str::CompactString>,
2289            }
2290        }
2291
2292        nestify::nest! {
2293            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2294            }
2295        }
2296
2297        pub type Response = Response200;
2298    }
2299}
2300pub mod servers_server_ws_permissions {
2301    use super::*;
2302
2303    pub mod post {
2304        use super::*;
2305
2306        nestify::nest! {
2307            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
2308                #[schema(inline)]
2309                pub user_permissions: Vec<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBodyUserPermissions {
2310                    #[schema(inline)]
2311                    pub user: uuid::Uuid,
2312                    #[schema(inline)]
2313                    pub permissions: Vec<compact_str::CompactString>,
2314                    #[schema(inline)]
2315                    pub ignored_files: Vec<compact_str::CompactString>,
2316                }>,
2317            }
2318        }
2319
2320        nestify::nest! {
2321            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2322            }
2323        }
2324
2325        pub type Response = Response200;
2326    }
2327}
2328pub mod system {
2329    use super::*;
2330
2331    pub mod get {
2332        use super::*;
2333
2334        nestify::nest! {
2335            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2336                #[schema(inline)]
2337                pub architecture: compact_str::CompactString,
2338                #[schema(inline)]
2339                pub cpu_count: u64,
2340                #[schema(inline)]
2341                pub kernel_version: compact_str::CompactString,
2342                #[schema(inline)]
2343                pub os: compact_str::CompactString,
2344                #[schema(inline)]
2345                pub version: compact_str::CompactString,
2346            }
2347        }
2348
2349        pub type Response = Response200;
2350    }
2351}
2352pub mod system_config {
2353    use super::*;
2354
2355    pub mod get {
2356        use super::*;
2357
2358        nestify::nest! {
2359            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2360                #[schema(inline)]
2361                pub debug: bool,
2362                #[schema(inline)]
2363                pub app_name: compact_str::CompactString,
2364                #[schema(inline)]
2365                pub uuid: uuid::Uuid,
2366                #[schema(inline)]
2367                pub token_id: compact_str::CompactString,
2368                #[schema(inline)]
2369                pub token: compact_str::CompactString,
2370                #[schema(inline)]
2371                pub api: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200Api {
2372                    #[schema(inline)]
2373                    pub host: compact_str::CompactString,
2374                    #[schema(inline)]
2375                    pub port: u32,
2376                    #[schema(inline)]
2377                    pub ssl: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200ApiSsl {
2378                        #[schema(inline)]
2379                        pub enabled: bool,
2380                        #[schema(inline)]
2381                        pub ktls_enabled: bool,
2382                        #[schema(inline)]
2383                        pub cert: compact_str::CompactString,
2384                        #[schema(inline)]
2385                        pub key: compact_str::CompactString,
2386                    },
2387
2388                    #[schema(inline)]
2389                    pub redirects: IndexMap<compact_str::CompactString, compact_str::CompactString>,
2390                    #[schema(inline)]
2391                    pub disable_openapi_docs: bool,
2392                    #[schema(inline)]
2393                    pub disable_remote_download: bool,
2394                    #[schema(inline)]
2395                    pub server_remote_download_limit: u64,
2396                    #[schema(inline)]
2397                    pub remote_download_blocked_cidrs: Vec<compact_str::CompactString>,
2398                    #[schema(inline)]
2399                    pub disable_directory_size: bool,
2400                    #[schema(inline)]
2401                    pub directory_entry_limit: u64,
2402                    #[schema(inline)]
2403                    pub send_offline_server_logs: bool,
2404                    #[schema(inline)]
2405                    pub file_search_threads: u64,
2406                    #[schema(inline)]
2407                    pub file_copy_threads: u64,
2408                    #[schema(inline)]
2409                    pub file_decompression_threads: u64,
2410                    #[schema(inline)]
2411                    pub file_compression_threads: u64,
2412                    #[schema(inline)]
2413                    pub upload_limit: MiB,
2414                    #[schema(inline)]
2415                    pub max_jwt_uses: u64,
2416                    #[schema(inline)]
2417                    pub trusted_proxies: Vec<compact_str::CompactString>,
2418                    #[schema(inline)]
2419                    pub schedule: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200ApiSchedule {
2420                        #[schema(inline)]
2421                        pub steps: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200ApiScheduleSteps {
2422                            #[schema(inline)]
2423                            pub http_request: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200ApiScheduleStepsHttpRequest {
2424                                #[schema(inline)]
2425                                pub enabled: bool,
2426                                #[schema(inline)]
2427                                pub requests: u32,
2428                                #[schema(inline)]
2429                                pub window_seconds: u64,
2430                                #[schema(inline)]
2431                                pub max_response_size: u64,
2432                                #[schema(inline)]
2433                                pub blocked_cidrs: Vec<compact_str::CompactString>,
2434                            },
2435
2436                        },
2437
2438                    },
2439
2440                },
2441
2442                #[schema(inline)]
2443                pub system: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200System {
2444                    #[schema(inline)]
2445                    pub root_directory: SystemPath,
2446                    #[schema(inline)]
2447                    pub log_directory: SystemPath,
2448                    #[schema(inline)]
2449                    pub data: SystemPath,
2450                    #[schema(inline)]
2451                    pub diffs_directory: SystemPath,
2452                    #[schema(inline)]
2453                    pub vmount_directory: SystemPath,
2454                    #[schema(inline)]
2455                    pub archive_directory: SystemPath,
2456                    #[schema(inline)]
2457                    pub backup_directory: SystemPath,
2458                    #[schema(inline)]
2459                    pub tmp_directory: SystemPath,
2460                    #[schema(inline)]
2461                    pub username: compact_str::CompactString,
2462                    #[schema(inline)]
2463                    pub timezone: compact_str::CompactString,
2464                    #[schema(inline)]
2465                    pub user: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemUser {
2466                        #[schema(inline)]
2467                        pub rootless: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemUserRootless {
2468                            #[schema(inline)]
2469                            pub enabled: bool,
2470                            #[schema(inline)]
2471                            pub container_uid: u32,
2472                            #[schema(inline)]
2473                            pub container_gid: u32,
2474                        },
2475
2476                        #[schema(inline)]
2477                        pub uid: u32,
2478                        #[schema(inline)]
2479                        pub gid: u32,
2480                    },
2481
2482                    #[schema(inline)]
2483                    pub passwd: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemPasswd {
2484                        #[schema(inline)]
2485                        pub enabled: bool,
2486                        #[schema(inline)]
2487                        pub directory: SystemPath,
2488                    },
2489
2490                    #[schema(inline)]
2491                    pub machine_id: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemMachineId {
2492                        #[schema(inline)]
2493                        pub enabled: bool,
2494                    },
2495
2496                    #[schema(inline)]
2497                    pub disk_check_concurrency: u64,
2498                    #[schema(inline)]
2499                    pub disk_check_interval: u64,
2500                    #[schema(inline)]
2501                    pub full_disk_check_every: u64,
2502                    #[schema(inline)]
2503                    pub disk_check_use_inotify: bool,
2504                    #[schema(inline)]
2505                    pub disk_limiter_mode: DiskLimiterMode,
2506                    #[schema(inline)]
2507                    pub activity_send_interval: u64,
2508                    #[schema(inline)]
2509                    pub activity_send_count: u64,
2510                    #[schema(inline)]
2511                    pub check_permissions_on_boot: bool,
2512                    #[schema(inline)]
2513                    pub check_permissions_on_boot_threads: u64,
2514                    #[schema(inline)]
2515                    pub websocket_log_count: u64,
2516                    #[schema(inline)]
2517                    pub tcp_congestion_control: compact_str::CompactString,
2518                    #[schema(inline)]
2519                    pub sftp: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemSftp {
2520                        #[schema(inline)]
2521                        pub enabled: bool,
2522                        #[schema(inline)]
2523                        pub bind_address: compact_str::CompactString,
2524                        #[schema(inline)]
2525                        pub bind_port: u32,
2526                        #[schema(inline)]
2527                        pub read_only: bool,
2528                        #[schema(inline)]
2529                        pub key_algorithm: compact_str::CompactString,
2530                        #[schema(inline)]
2531                        pub disable_password_auth: bool,
2532                        #[schema(inline)]
2533                        pub directory_entry_limit: u64,
2534                        #[schema(inline)]
2535                        pub directory_entry_send_amount: u64,
2536                        #[schema(inline)]
2537                        pub limits: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemSftpLimits {
2538                            #[schema(inline)]
2539                            pub authentication_password_attempts: u64,
2540                            #[schema(inline)]
2541                            pub authentication_pubkey_attempts: u64,
2542                            #[schema(inline)]
2543                            pub authentication_cooldown: u64,
2544                            #[schema(inline)]
2545                            pub max_connections_per_user: u64,
2546                            #[schema(inline)]
2547                            pub max_channels_per_connection: u64,
2548                            #[schema(inline)]
2549                            pub max_handles_per_channel: u64,
2550                            #[schema(inline)]
2551                            pub max_handles_total: u64,
2552                        },
2553
2554                        #[schema(inline)]
2555                        pub shell: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemSftpShell {
2556                            #[schema(inline)]
2557                            pub enabled: bool,
2558                            #[schema(inline)]
2559                            pub cli: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemSftpShellCli {
2560                                #[schema(inline)]
2561                                pub name: compact_str::CompactString,
2562                            },
2563
2564                        },
2565
2566                        #[schema(inline)]
2567                        pub activity: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemSftpActivity {
2568                            #[schema(inline)]
2569                            pub log_logins: bool,
2570                            #[schema(inline)]
2571                            pub log_file_reads: bool,
2572                        },
2573
2574                    },
2575
2576                    #[schema(inline)]
2577                    pub crash_detection: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemCrashDetection {
2578                        #[schema(inline)]
2579                        pub enabled: bool,
2580                        #[schema(inline)]
2581                        pub detect_clean_exit_as_crash: bool,
2582                        #[schema(inline)]
2583                        pub timeout: u64,
2584                    },
2585
2586                    #[schema(inline)]
2587                    pub file_history: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemFileHistory {
2588                        #[schema(inline)]
2589                        pub enabled: bool,
2590                        #[schema(inline)]
2591                        pub zstd_level: i32,
2592                        #[schema(inline)]
2593                        pub anchor_interval: u64,
2594                        #[schema(inline)]
2595                        pub keep_chains: u64,
2596                        #[schema(inline)]
2597                        pub file_size_cap: u64,
2598                        #[schema(inline)]
2599                        pub per_file_disk_budget: u64,
2600                        #[schema(inline)]
2601                        pub per_server_disk_budget: u64,
2602                        #[schema(inline)]
2603                        pub maintenance_interval: u64,
2604                    },
2605
2606                    #[schema(inline)]
2607                    pub file_collaboration: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemFileCollaboration {
2608                        #[schema(inline)]
2609                        pub enabled: bool,
2610                        #[schema(inline)]
2611                        pub file_size_cap: u64,
2612                        #[schema(inline)]
2613                        pub max_sessions_per_server: u64,
2614                        #[schema(inline)]
2615                        pub max_sessions_per_connection: u64,
2616                        #[schema(inline)]
2617                        pub max_editors_per_session: u64,
2618                        #[schema(inline)]
2619                        pub max_cursors_per_connection: u64,
2620                        #[schema(inline)]
2621                        pub session_grace_period: u64,
2622                    },
2623
2624                    #[schema(inline)]
2625                    pub backups: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackups {
2626                        #[schema(inline)]
2627                        pub write_limit: MiB,
2628                        #[schema(inline)]
2629                        pub read_limit: MiB,
2630                        #[schema(inline)]
2631                        pub compression_level: CompressionLevel,
2632                        #[schema(inline)]
2633                        pub mounting: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsMounting {
2634                            #[schema(inline)]
2635                            pub enabled: bool,
2636                            #[schema(inline)]
2637                            pub path: compact_str::CompactString,
2638                        },
2639
2640                        #[schema(inline)]
2641                        pub wings: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsWings {
2642                            #[schema(inline)]
2643                            pub create_threads: u64,
2644                            #[schema(inline)]
2645                            pub restore_threads: u64,
2646                            #[schema(inline)]
2647                            pub archive_format: ArchiveFormat,
2648                        },
2649
2650                        #[schema(inline)]
2651                        pub s3: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsS3 {
2652                            #[schema(inline)]
2653                            pub create_threads: u64,
2654                            #[schema(inline)]
2655                            pub part_upload_timeout: u64,
2656                            #[schema(inline)]
2657                            pub retry_limit: u64,
2658                        },
2659
2660                        #[schema(inline)]
2661                        pub ddup_bak: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsDdupBak {
2662                            #[schema(inline)]
2663                            pub create_threads: u64,
2664                            #[schema(inline)]
2665                            pub compression_format: SystemBackupsDdupBakCompressionFormat,
2666                        },
2667
2668                        #[schema(inline)]
2669                        pub restic: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsRestic {
2670                            #[schema(inline)]
2671                            pub repository: SystemPath,
2672                            #[schema(inline)]
2673                            pub password_file: SystemPath,
2674                            #[schema(inline)]
2675                            pub retry_lock_seconds: u64,
2676                            #[schema(inline)]
2677                            pub environment: IndexMap<compact_str::CompactString, compact_str::CompactString>,
2678                        },
2679
2680                        #[schema(inline)]
2681                        pub btrfs: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsBtrfs {
2682                            #[schema(inline)]
2683                            pub restore_threads: u64,
2684                            #[schema(inline)]
2685                            pub create_read_only: bool,
2686                        },
2687
2688                        #[schema(inline)]
2689                        pub zfs: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsZfs {
2690                            #[schema(inline)]
2691                            pub restore_threads: u64,
2692                        },
2693
2694                        #[schema(inline)]
2695                        pub pbs: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemBackupsPbs {
2696                            #[schema(inline)]
2697                            pub create_threads: u64,
2698                            #[schema(inline)]
2699                            pub download_concurrency: u64,
2700                        },
2701
2702                    },
2703
2704                    #[schema(inline)]
2705                    pub transfers: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200SystemTransfers {
2706                        #[schema(inline)]
2707                        pub download_limit: MiB,
2708                    },
2709
2710                },
2711
2712                #[schema(inline)]
2713                pub docker: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200Docker {
2714                    #[schema(inline)]
2715                    pub socket: compact_str::CompactString,
2716                    #[schema(inline)]
2717                    pub server_name_in_container_name: bool,
2718                    #[schema(inline)]
2719                    pub delete_container_on_stop: bool,
2720                    #[schema(inline)]
2721                    pub network: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerNetwork {
2722                        #[schema(inline)]
2723                        pub interface: compact_str::CompactString,
2724                        #[schema(inline)]
2725                        pub disable_interface_binding: bool,
2726                        #[schema(inline)]
2727                        pub dns: Vec<compact_str::CompactString>,
2728                        #[schema(inline)]
2729                        pub dns_options: Vec<compact_str::CompactString>,
2730                        #[schema(inline)]
2731                        pub name: compact_str::CompactString,
2732                        #[schema(inline)]
2733                        pub ispn: bool,
2734                        #[schema(inline)]
2735                        pub driver: compact_str::CompactString,
2736                        #[schema(inline)]
2737                        pub mode: compact_str::CompactString,
2738                        #[schema(inline)]
2739                        pub is_internal: bool,
2740                        #[schema(inline)]
2741                        pub enable_icc: bool,
2742                        #[schema(inline)]
2743                        pub network_mtu: u64,
2744                        #[schema(inline)]
2745                        pub interfaces: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerNetworkInterfaces {
2746                            #[schema(inline)]
2747                            pub v4: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerNetworkInterfacesV4 {
2748                                #[schema(inline)]
2749                                pub enabled: bool,
2750                                #[schema(inline)]
2751                                pub subnet: compact_str::CompactString,
2752                                #[schema(inline)]
2753                                pub gateway: compact_str::CompactString,
2754                            },
2755
2756                            #[schema(inline)]
2757                            pub v6: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerNetworkInterfacesV6 {
2758                                #[schema(inline)]
2759                                pub enabled: bool,
2760                                #[schema(inline)]
2761                                pub subnet: compact_str::CompactString,
2762                                #[schema(inline)]
2763                                pub gateway: compact_str::CompactString,
2764                            },
2765
2766                        },
2767
2768                    },
2769
2770                    #[schema(inline)]
2771                    pub domainname: compact_str::CompactString,
2772                    #[schema(inline)]
2773                    pub registries: IndexMap<compact_str::CompactString, serde_json::Value>,
2774                    #[schema(inline)]
2775                    pub registry_image_fetch_cache: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerRegistryImageFetchCache {
2776                        #[schema(inline)]
2777                        pub enabled: bool,
2778                        #[schema(inline)]
2779                        pub duration: u64,
2780                        #[schema(inline)]
2781                        pub background_refresh: bool,
2782                    },
2783
2784                    #[schema(inline)]
2785                    pub tmpfs_size: MiB,
2786                    #[schema(inline)]
2787                    pub shm_size: MiB,
2788                    #[schema(inline)]
2789                    pub container_pid_limit: u64,
2790                    #[schema(inline)]
2791                    pub container_apply_seccomp: bool,
2792                    #[schema(inline)]
2793                    pub container_apparmor_profile: compact_str::CompactString,
2794                    #[schema(inline)]
2795                    pub container_ulimits: Vec<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerContainerUlimits {
2796                        #[schema(inline)]
2797                        pub name: compact_str::CompactString,
2798                        #[schema(inline)]
2799                        pub soft: i64,
2800                        #[schema(inline)]
2801                        pub hard: i64,
2802                    }>,
2803                    #[schema(inline)]
2804                    pub container_sysctls: IndexMap<compact_str::CompactString, compact_str::CompactString>,
2805                    #[schema(inline)]
2806                    pub numa_memory_binding: bool,
2807                    #[schema(inline)]
2808                    pub cpu_period: u64,
2809                    #[schema(inline)]
2810                    pub cfs_burst: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerCfsBurst {
2811                        #[schema(inline)]
2812                        pub enabled: bool,
2813                        #[schema(inline)]
2814                        pub multiple: f64,
2815                    },
2816
2817                    #[schema(inline)]
2818                    pub startup_boost: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerStartupBoost {
2819                        #[schema(inline)]
2820                        pub enabled: bool,
2821                        #[schema(inline)]
2822                        pub timeout: u64,
2823                        #[schema(inline)]
2824                        pub max_concurrent: u64,
2825                    },
2826
2827                    #[schema(inline)]
2828                    pub installer_limits: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerInstallerLimits {
2829                        #[schema(inline)]
2830                        pub timeout: u64,
2831                        #[schema(inline)]
2832                        pub memory: MiB,
2833                        #[schema(inline)]
2834                        pub cpu: u64,
2835                    },
2836
2837                    #[schema(inline)]
2838                    pub overhead: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerOverhead {
2839                        #[schema(inline)]
2840                        pub r#override: bool,
2841                        #[schema(inline)]
2842                        pub default_multiplier: f64,
2843                        #[schema(inline)]
2844                        pub multipliers: IndexMap<compact_str::CompactString, f64>,
2845                    },
2846
2847                    #[schema(inline)]
2848                    pub userns_mode: compact_str::CompactString,
2849                    #[schema(inline)]
2850                    pub log_config: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200DockerLogConfig {
2851                        #[schema(inline)]
2852                        pub r#type: compact_str::CompactString,
2853                        #[schema(inline)]
2854                        pub config: IndexMap<compact_str::CompactString, compact_str::CompactString>,
2855                    },
2856
2857                },
2858
2859                #[schema(inline)]
2860                pub throttles: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200Throttles {
2861                    #[schema(inline)]
2862                    pub enabled: bool,
2863                    #[schema(inline)]
2864                    pub lines: u64,
2865                    #[schema(inline)]
2866                    pub line_reset_interval: u64,
2867                },
2868
2869                #[schema(inline)]
2870                pub remote: compact_str::CompactString,
2871                #[schema(inline)]
2872                pub remote_headers: IndexMap<compact_str::CompactString, compact_str::CompactString>,
2873                #[schema(inline)]
2874                pub remote_query: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200RemoteQuery {
2875                    #[schema(inline)]
2876                    pub timeout: u64,
2877                    #[schema(inline)]
2878                    pub boot_servers_per_page: u64,
2879                    #[schema(inline)]
2880                    pub retry_limit: u64,
2881                },
2882
2883                #[schema(inline)]
2884                pub allowed_mounts: Vec<compact_str::CompactString>,
2885                #[schema(inline)]
2886                pub allowed_origins: Vec<compact_str::CompactString>,
2887                #[schema(inline)]
2888                pub allow_cors_private_network: bool,
2889                #[schema(inline)]
2890                pub ignore_panel_config_updates: bool,
2891                #[schema(inline)]
2892                pub ignore_panel_wings_upgrades: bool,
2893            }
2894        }
2895
2896        pub type Response = Response200;
2897    }
2898}
2899pub mod system_logs {
2900    use super::*;
2901
2902    pub mod get {
2903        use super::*;
2904
2905        nestify::nest! {
2906            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2907                #[schema(inline)]
2908                pub log_files: Vec<#[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200LogFiles {
2909                    #[schema(inline)]
2910                    pub name: compact_str::CompactString,
2911                    #[schema(inline)]
2912                    pub compression_type: CompressionType,
2913                    #[schema(inline)]
2914                    pub size: u64,
2915                    #[schema(inline)]
2916                    pub last_modified: chrono::DateTime<chrono::Local>,
2917                }>,
2918            }
2919        }
2920
2921        pub type Response = Response200;
2922    }
2923}
2924pub mod system_logs_file {
2925    use super::*;
2926
2927    pub mod get {
2928        use super::*;
2929
2930        pub type Response200 = AsyncResponseReader;
2931
2932        pub type Response404 = ApiError;
2933
2934        pub type Response = Response200;
2935
2936        #[derive(Debug, Clone, Default)]
2937        #[allow(clippy::manual_non_exhaustive)]
2938        pub struct Query {
2939            pub lines: Option<u64>,
2940            #[doc(hidden)]
2941            pub __priv: (),
2942        }
2943    }
2944}
2945pub mod system_overview {
2946    use super::*;
2947
2948    pub mod get {
2949        use super::*;
2950
2951        nestify::nest! {
2952            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
2953                #[schema(inline)]
2954                pub version: compact_str::CompactString,
2955                #[schema(inline)]
2956                pub local_time: chrono::DateTime<chrono::Local>,
2957                #[schema(inline)]
2958                pub container_type: AppContainerType,
2959                #[schema(inline)]
2960                pub cpu: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200Cpu {
2961                    #[schema(inline)]
2962                    pub name: compact_str::CompactString,
2963                    #[schema(inline)]
2964                    pub brand: compact_str::CompactString,
2965                    #[schema(inline)]
2966                    pub vendor_id: compact_str::CompactString,
2967                    #[schema(inline)]
2968                    pub frequency_mhz: u64,
2969                    #[schema(inline)]
2970                    pub cpu_count: u64,
2971                },
2972
2973                #[schema(inline)]
2974                pub memory: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200Memory {
2975                    #[schema(inline)]
2976                    pub total_bytes: u64,
2977                    #[schema(inline)]
2978                    pub free_bytes: u64,
2979                    #[schema(inline)]
2980                    pub used_bytes: u64,
2981                    #[schema(inline)]
2982                    pub used_bytes_process: u64,
2983                },
2984
2985                #[schema(inline)]
2986                pub servers: #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200Servers {
2987                    #[schema(inline)]
2988                    pub total: u64,
2989                    #[schema(inline)]
2990                    pub online: u64,
2991                    #[schema(inline)]
2992                    pub offline: u64,
2993                },
2994
2995                #[schema(inline)]
2996                pub architecture: compact_str::CompactString,
2997                #[schema(inline)]
2998                pub kernel_version: compact_str::CompactString,
2999            }
3000        }
3001
3002        pub type Response = Response200;
3003    }
3004}
3005pub mod system_restic_prune {
3006    use super::*;
3007
3008    pub mod get {
3009        use super::*;
3010
3011        nestify::nest! {
3012            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
3013                #[schema(inline)]
3014                pub result: ResticTaskResult,
3015            }
3016        }
3017
3018        pub type Response404 = ApiError;
3019
3020        pub type Response = Response200;
3021    }
3022
3023    pub mod post {
3024        use super::*;
3025
3026        nestify::nest! {
3027            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
3028                #[schema(inline)]
3029                pub configuration: Option<ResticBackupConfiguration>,
3030                #[schema(inline)]
3031                pub dry_run: bool,
3032                #[schema(inline)]
3033                pub foreground: bool,
3034            }
3035        }
3036
3037        nestify::nest! {
3038            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
3039                #[schema(inline)]
3040                pub result: ResticTaskResult,
3041            }
3042        }
3043
3044        nestify::nest! {
3045            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
3046            }
3047        }
3048
3049        pub type Response409 = ApiError;
3050
3051        #[derive(Deserialize)]
3052        #[serde(untagged)]
3053        pub enum Response {
3054            Ok(Response200),
3055            Accepted(Response202),
3056        }
3057    }
3058}
3059pub mod system_restic_stats {
3060    use super::*;
3061
3062    pub mod get {
3063        use super::*;
3064
3065        nestify::nest! {
3066            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
3067                #[schema(inline)]
3068                pub result: ResticTaskResult,
3069            }
3070        }
3071
3072        pub type Response404 = ApiError;
3073
3074        pub type Response = Response200;
3075    }
3076
3077    pub mod post {
3078        use super::*;
3079
3080        nestify::nest! {
3081            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
3082                #[schema(inline)]
3083                pub configuration: Option<ResticBackupConfiguration>,
3084                #[schema(inline)]
3085                pub mode: Option<compact_str::CompactString>,
3086                #[schema(inline)]
3087                pub foreground: bool,
3088            }
3089        }
3090
3091        nestify::nest! {
3092            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
3093                #[schema(inline)]
3094                pub result: ResticTaskResult,
3095            }
3096        }
3097
3098        nestify::nest! {
3099            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
3100            }
3101        }
3102
3103        pub type Response409 = ApiError;
3104
3105        #[derive(Deserialize)]
3106        #[serde(untagged)]
3107        pub enum Response {
3108            Ok(Response200),
3109            Accepted(Response202),
3110        }
3111    }
3112}
3113pub mod system_restic_unlock {
3114    use super::*;
3115
3116    pub mod get {
3117        use super::*;
3118
3119        nestify::nest! {
3120            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
3121                #[schema(inline)]
3122                pub result: ResticTaskResult,
3123            }
3124        }
3125
3126        pub type Response404 = ApiError;
3127
3128        pub type Response = Response200;
3129    }
3130
3131    pub mod post {
3132        use super::*;
3133
3134        nestify::nest! {
3135            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
3136                #[schema(inline)]
3137                pub configuration: Option<ResticBackupConfiguration>,
3138                #[schema(inline)]
3139                pub remove_all: bool,
3140                #[schema(inline)]
3141                pub foreground: bool,
3142            }
3143        }
3144
3145        nestify::nest! {
3146            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
3147                #[schema(inline)]
3148                pub result: ResticTaskResult,
3149            }
3150        }
3151
3152        nestify::nest! {
3153            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
3154            }
3155        }
3156
3157        pub type Response409 = ApiError;
3158
3159        pub type Response417 = ApiError;
3160
3161        #[derive(Deserialize)]
3162        #[serde(untagged)]
3163        pub enum Response {
3164            Ok(Response200),
3165            Accepted(Response202),
3166        }
3167    }
3168}
3169pub mod system_stats {
3170    use super::*;
3171
3172    pub mod get {
3173        use super::*;
3174
3175        nestify::nest! {
3176            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
3177                #[schema(inline)]
3178                pub stats: SystemStats,
3179            }
3180        }
3181
3182        pub type Response = Response200;
3183    }
3184}
3185pub mod system_upgrade {
3186    use super::*;
3187
3188    pub mod post {
3189        use super::*;
3190
3191        nestify::nest! {
3192            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct RequestBody {
3193                #[schema(inline)]
3194                pub url: compact_str::CompactString,
3195                #[schema(inline)]
3196                pub headers: IndexMap<compact_str::CompactString, compact_str::CompactString>,
3197                #[schema(inline)]
3198                pub sha256: compact_str::CompactString,
3199                #[schema(inline)]
3200                pub restart_command: compact_str::CompactString,
3201                #[schema(inline)]
3202                pub restart_command_args: Vec<compact_str::CompactString>,
3203            }
3204        }
3205
3206        nestify::nest! {
3207            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response202 {
3208                #[schema(inline)]
3209                pub applied: bool,
3210            }
3211        }
3212
3213        nestify::nest! {
3214            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response409 {
3215                #[schema(inline)]
3216                pub error: compact_str::CompactString,
3217            }
3218        }
3219
3220        pub type Response = Response202;
3221    }
3222}
3223pub mod transfers {
3224    use super::*;
3225
3226    pub mod get {
3227        use super::*;
3228
3229        type Response200 = IndexMap<uuid::Uuid, TransferProgress>;
3230        pub type Response404 = ApiError;
3231
3232        pub type Response = Response200;
3233    }
3234
3235    pub mod post {
3236        use super::*;
3237
3238        nestify::nest! {
3239            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
3240            }
3241        }
3242
3243        pub type Response401 = ApiError;
3244
3245        pub type Response409 = ApiError;
3246
3247        pub type Response = Response200;
3248    }
3249}
3250pub mod transfers_capabilities {
3251    use super::*;
3252
3253    pub mod get {
3254        use super::*;
3255
3256        pub type Response200 = TransferCapabilities;
3257
3258        pub type Response = Response200;
3259    }
3260}
3261pub mod transfers_files {
3262    use super::*;
3263
3264    pub mod post {
3265        use super::*;
3266
3267        nestify::nest! {
3268            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
3269            }
3270        }
3271
3272        pub type Response401 = ApiError;
3273
3274        pub type Response409 = ApiError;
3275
3276        pub type Response = Response200;
3277    }
3278}
3279pub mod transfers_query {
3280    use super::*;
3281
3282    pub mod get {
3283        use super::*;
3284
3285        pub type Response200 = TransferCapabilities;
3286
3287        pub type Response401 = ApiError;
3288
3289        pub type Response = Response200;
3290    }
3291}
3292pub mod transfers_server {
3293    use super::*;
3294
3295    pub mod delete {
3296        use super::*;
3297
3298        nestify::nest! {
3299            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
3300            }
3301        }
3302
3303        pub type Response404 = ApiError;
3304
3305        pub type Response = Response200;
3306    }
3307}
3308pub mod update {
3309    use super::*;
3310
3311    pub mod post {
3312        use super::*;
3313
3314        pub type RequestBody = serde_json::Value;
3315
3316        nestify::nest! {
3317            #[derive(Debug, ToSchema, Deserialize, Serialize, Clone)] pub struct Response200 {
3318                #[schema(inline)]
3319                pub applied: bool,
3320            }
3321        }
3322
3323        pub type Response = Response200;
3324    }
3325}