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

wings_api/
lib.rs
