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