mountos_admin_sdk/
types_gen.rs

1// Code generated by gen; DO NOT EDIT.
2
3use serde::{Deserialize, Serialize};
4
5/// Client configuration.
6#[derive(Debug, Clone, Default)]
7pub struct Config {
8    /// Base URL of the appserv provider API, e.g. `https://appserv.example.com`.
9    pub base_url: String,
10    /// Base64-encoded ED25519 private key (32-byte seed or 64-byte seed+public key).
11    pub private_key: String,
12    /// Optional dashboard operator context, signed into each request.
13    pub dashboard_user: Option<DashboardUser>,
14    /// Dedicated HMAC secret for the `X-MountOS-Dashboard-User` header (appserv
15    /// `DASHBOARD_USER_HMAC_KEY`); required when `dashboard_user` is set.
16    pub dashboard_hmac_key: Option<String>,
17}
18
19/// Page-based pagination options.
20#[derive(Debug, Clone, Default)]
21pub struct ListOptions {
22    pub page: Option<i64>,
23    pub limit: Option<i64>,
24}
25
26/// Pagination metadata returned by page-based list endpoints.
27#[derive(Debug, Clone, Deserialize)]
28pub struct PaginationMeta {
29    pub page: i64,
30    pub limit: i64,
31    pub total: i64,
32    #[serde(rename = "totalPages")]
33    pub total_pages: i64,
34}
35
36/// Page-based list response.
37#[derive(Debug, Clone, Deserialize)]
38pub struct PaginatedResponse<T> {
39    pub items: Vec<T>,
40    pub pagination: PaginationMeta,
41}
42
43/// Cursor-based list response.
44#[derive(Debug, Clone, Deserialize)]
45pub struct CursorPaginatedResponse<T> {
46    pub items: Vec<T>,
47    #[serde(rename = "nextCursor")]
48    pub next_cursor: Option<i64>,
49}
50
51/// Identifier returned by create/edit/toggle endpoints.
52#[derive(Debug, Clone, Deserialize)]
53pub struct IdResponse {
54    pub id: i64,
55}
56
57/// `ClientSessionStatus` values accepted/returned on the wire. `UnknownValue` preserves a
58/// value this SDK does not recognize yet, for forward compatibility with
59/// a server that has introduced a new ClientSessionStatus value.
60#[derive(Debug, Clone, PartialEq, Eq)]
61pub enum ClientSessionStatus {
62    Connected,
63    Active,
64    Degraded,
65    Disconnected,
66    Expired,
67    Unknown,
68    /// A value not defined when this SDK was generated.
69    UnknownValue(String),
70}
71
72impl ClientSessionStatus {
73    /// Returns the wire string for this value.
74    pub fn as_str(&self) -> &str {
75        match self {
76            ClientSessionStatus::Connected => "connected",
77            ClientSessionStatus::Active => "active",
78            ClientSessionStatus::Degraded => "degraded",
79            ClientSessionStatus::Disconnected => "disconnected",
80            ClientSessionStatus::Expired => "expired",
81            ClientSessionStatus::Unknown => "unknown",
82            ClientSessionStatus::UnknownValue(s) => s.as_str(),
83        }
84    }
85
86    /// Reports whether this is one of the values defined when this SDK was
87    /// generated (false for `UnknownValue`).
88    pub fn is_known(&self) -> bool {
89        !matches!(self, ClientSessionStatus::UnknownValue(_))
90    }
91}
92
93impl std::fmt::Display for ClientSessionStatus {
94    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
95        f.write_str(self.as_str())
96    }
97}
98
99impl From<&str> for ClientSessionStatus {
100    fn from(s: &str) -> Self {
101        match s {
102            "connected" => ClientSessionStatus::Connected,
103            "active" => ClientSessionStatus::Active,
104            "degraded" => ClientSessionStatus::Degraded,
105            "disconnected" => ClientSessionStatus::Disconnected,
106            "expired" => ClientSessionStatus::Expired,
107            "unknown" => ClientSessionStatus::Unknown,
108            other => ClientSessionStatus::UnknownValue(other.to_string()),
109        }
110    }
111}
112
113impl Serialize for ClientSessionStatus {
114    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
115    where
116        S: serde::Serializer,
117    {
118        serializer.serialize_str(self.as_str())
119    }
120}
121
122impl<'de> Deserialize<'de> for ClientSessionStatus {
123    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
124    where
125        D: serde::Deserializer<'de>,
126    {
127        let s = String::deserialize(deserializer)?;
128        Ok(ClientSessionStatus::from(s.as_str()))
129    }
130}
131
132/// `CopysetState` values accepted/returned on the wire. `Unknown` preserves a
133/// value this SDK does not recognize yet, for forward compatibility with
134/// a server that has introduced a new CopysetState value.
135#[derive(Debug, Clone, PartialEq, Eq)]
136pub enum CopysetState {
137    Active,
138    Draining,
139    SyncedDrained,
140    Retired,
141    /// A value not defined when this SDK was generated.
142    Unknown(String),
143}
144
145impl CopysetState {
146    /// Returns the wire string for this value.
147    pub fn as_str(&self) -> &str {
148        match self {
149            CopysetState::Active => "active",
150            CopysetState::Draining => "draining",
151            CopysetState::SyncedDrained => "synced_drained",
152            CopysetState::Retired => "retired",
153            CopysetState::Unknown(s) => s.as_str(),
154        }
155    }
156
157    /// Reports whether this is one of the values defined when this SDK was
158    /// generated (false for `Unknown`).
159    pub fn is_known(&self) -> bool {
160        !matches!(self, CopysetState::Unknown(_))
161    }
162}
163
164impl std::fmt::Display for CopysetState {
165    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
166        f.write_str(self.as_str())
167    }
168}
169
170impl From<&str> for CopysetState {
171    fn from(s: &str) -> Self {
172        match s {
173            "active" => CopysetState::Active,
174            "draining" => CopysetState::Draining,
175            "synced_drained" => CopysetState::SyncedDrained,
176            "retired" => CopysetState::Retired,
177            other => CopysetState::Unknown(other.to_string()),
178        }
179    }
180}
181
182impl Serialize for CopysetState {
183    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
184    where
185        S: serde::Serializer,
186    {
187        serializer.serialize_str(self.as_str())
188    }
189}
190
191impl<'de> Deserialize<'de> for CopysetState {
192    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
193    where
194        D: serde::Deserializer<'de>,
195    {
196        let s = String::deserialize(deserializer)?;
197        Ok(CopysetState::from(s.as_str()))
198    }
199}
200
201/// `LicenseQuotaState` values accepted/returned on the wire. `Unknown` preserves a
202/// value this SDK does not recognize yet, for forward compatibility with
203/// a server that has introduced a new LicenseQuotaState value.
204#[derive(Debug, Clone, PartialEq, Eq)]
205pub enum LicenseQuotaState {
206    Ok,
207    Exceeded,
208    /// A value not defined when this SDK was generated.
209    Unknown(String),
210}
211
212impl LicenseQuotaState {
213    /// Returns the wire string for this value.
214    pub fn as_str(&self) -> &str {
215        match self {
216            LicenseQuotaState::Ok => "ok",
217            LicenseQuotaState::Exceeded => "exceeded",
218            LicenseQuotaState::Unknown(s) => s.as_str(),
219        }
220    }
221
222    /// Reports whether this is one of the values defined when this SDK was
223    /// generated (false for `Unknown`).
224    pub fn is_known(&self) -> bool {
225        !matches!(self, LicenseQuotaState::Unknown(_))
226    }
227}
228
229impl std::fmt::Display for LicenseQuotaState {
230    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
231        f.write_str(self.as_str())
232    }
233}
234
235impl From<&str> for LicenseQuotaState {
236    fn from(s: &str) -> Self {
237        match s {
238            "ok" => LicenseQuotaState::Ok,
239            "exceeded" => LicenseQuotaState::Exceeded,
240            other => LicenseQuotaState::Unknown(other.to_string()),
241        }
242    }
243}
244
245impl Serialize for LicenseQuotaState {
246    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
247    where
248        S: serde::Serializer,
249    {
250        serializer.serialize_str(self.as_str())
251    }
252}
253
254impl<'de> Deserialize<'de> for LicenseQuotaState {
255    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
256    where
257        D: serde::Deserializer<'de>,
258    {
259        let s = String::deserialize(deserializer)?;
260        Ok(LicenseQuotaState::from(s.as_str()))
261    }
262}
263
264/// `LicenseStatus` values accepted/returned on the wire. `Unknown` preserves a
265/// value this SDK does not recognize yet, for forward compatibility with
266/// a server that has introduced a new LicenseStatus value.
267#[derive(Debug, Clone, PartialEq, Eq)]
268pub enum LicenseStatus {
269    Valid,
270    Expiring,
271    Grace,
272    ExpiredAccess,
273    Expired,
274    /// A value not defined when this SDK was generated.
275    Unknown(String),
276}
277
278impl LicenseStatus {
279    /// Returns the wire string for this value.
280    pub fn as_str(&self) -> &str {
281        match self {
282            LicenseStatus::Valid => "valid",
283            LicenseStatus::Expiring => "expiring",
284            LicenseStatus::Grace => "grace",
285            LicenseStatus::ExpiredAccess => "expired_access",
286            LicenseStatus::Expired => "expired",
287            LicenseStatus::Unknown(s) => s.as_str(),
288        }
289    }
290
291    /// Reports whether this is one of the values defined when this SDK was
292    /// generated (false for `Unknown`).
293    pub fn is_known(&self) -> bool {
294        !matches!(self, LicenseStatus::Unknown(_))
295    }
296}
297
298impl std::fmt::Display for LicenseStatus {
299    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
300        f.write_str(self.as_str())
301    }
302}
303
304impl From<&str> for LicenseStatus {
305    fn from(s: &str) -> Self {
306        match s {
307            "valid" => LicenseStatus::Valid,
308            "expiring" => LicenseStatus::Expiring,
309            "grace" => LicenseStatus::Grace,
310            "expired_access" => LicenseStatus::ExpiredAccess,
311            "expired" => LicenseStatus::Expired,
312            other => LicenseStatus::Unknown(other.to_string()),
313        }
314    }
315}
316
317impl Serialize for LicenseStatus {
318    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
319    where
320        S: serde::Serializer,
321    {
322        serializer.serialize_str(self.as_str())
323    }
324}
325
326impl<'de> Deserialize<'de> for LicenseStatus {
327    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
328    where
329        D: serde::Deserializer<'de>,
330    {
331        let s = String::deserialize(deserializer)?;
332        Ok(LicenseStatus::from(s.as_str()))
333    }
334}
335
336#[derive(Debug, Clone, Serialize, Deserialize)]
337pub struct Account {
338    pub id: i64,
339    pub name: String,
340    pub description: String,
341    #[serde(rename = "iconUrl", skip_serializing_if = "Option::is_none")]
342    pub icon_url: Option<String>,
343    #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
344    pub provider_info: Option<serde_json::Value>,
345    #[serde(rename = "liveVolume")]
346    pub live_volume: i64,
347    #[serde(rename = "totalVolume")]
348    pub total_volume: i64,
349    #[serde(rename = "quotaLimit")]
350    pub quota_limit: i64,
351    #[serde(rename = "quotaExcessPct")]
352    pub quota_excess_pct: i32,
353    #[serde(rename = "isActive")]
354    pub is_active: bool,
355    pub locked: bool,
356    #[serde(skip_serializing_if = "Option::is_none")]
357    pub retention: Option<RetentionPolicy>,
358    #[serde(rename = "createdAt")]
359    pub created_at: String,
360    #[serde(rename = "updatedAt")]
361    pub updated_at: String,
362}
363
364#[derive(Debug, Clone, Serialize, Deserialize)]
365pub struct User {
366    pub id: i64,
367    #[serde(rename = "accountId")]
368    pub account_id: i64,
369    pub username: String,
370    pub email: String,
371    pub name: String,
372    #[serde(rename = "isActive")]
373    pub is_active: bool,
374}
375
376#[derive(Debug, Clone, Serialize, Deserialize)]
377pub struct Region {
378    pub id: i64,
379    #[serde(rename = "exportId")]
380    pub export_id: String,
381    #[serde(rename = "accountId")]
382    pub account_id: i64,
383    pub name: String,
384    #[serde(rename = "liveVolume")]
385    pub live_volume: i64,
386    #[serde(rename = "totalVolume")]
387    pub total_volume: i64,
388    #[serde(rename = "isActive")]
389    pub is_active: bool,
390    #[serde(rename = "createdAt")]
391    pub created_at: String,
392    #[serde(rename = "updatedAt")]
393    pub updated_at: String,
394}
395
396#[derive(Debug, Clone, Serialize, Deserialize)]
397pub struct MetadataCluster {
398    pub id: i64,
399    #[serde(rename = "exportId")]
400    pub export_id: String,
401    #[serde(rename = "regionId")]
402    pub region_id: i64,
403    pub name: String,
404    #[serde(rename = "defaultCluster")]
405    pub default_cluster: bool,
406    #[serde(rename = "isReady")]
407    pub is_ready: bool,
408    #[serde(rename = "isActive")]
409    pub is_active: bool,
410    #[serde(rename = "createdAt")]
411    pub created_at: String,
412    #[serde(rename = "updatedAt")]
413    pub updated_at: String,
414}
415
416#[derive(Debug, Clone, Serialize, Deserialize)]
417pub struct Storage {
418    pub id: i64,
419    pub uuid: String,
420    pub account: Ref,
421    #[serde(rename = "regionInfo")]
422    pub region_info: Ref,
423    pub name: String,
424    #[serde(skip_serializing_if = "Option::is_none")]
425    pub description: Option<String>,
426    #[serde(rename = "storageType")]
427    pub storage_type: String,
428    #[serde(rename = "providerType")]
429    pub provider_type: String,
430    pub endpoint: String,
431    #[serde(skip_serializing_if = "Option::is_none")]
432    pub region: Option<String>,
433    #[serde(skip_serializing_if = "Option::is_none")]
434    pub bucket: Option<String>,
435    #[serde(skip_serializing_if = "Option::is_none")]
436    pub base: Option<String>,
437    #[serde(rename = "physicalFingerprint", skip_serializing_if = "Option::is_none")]
438    pub physical_fingerprint: Option<String>,
439    #[serde(rename = "blockRegion", skip_serializing_if = "Option::is_none")]
440    pub block_region: Option<String>,
441    #[serde(rename = "blockSize", skip_serializing_if = "Option::is_none")]
442    pub block_size: Option<i32>,
443    #[serde(rename = "directAccess", skip_serializing_if = "Option::is_none")]
444    pub direct_access: Option<bool>,
445    #[serde(rename = "isActive")]
446    pub is_active: bool,
447    #[serde(rename = "createdAt")]
448    pub created_at: String,
449    #[serde(rename = "updatedAt")]
450    pub updated_at: String,
451}
452
453#[derive(Debug, Clone, Serialize, Deserialize)]
454pub struct BlockVolume {
455    pub id: String,
456    #[serde(skip_serializing_if = "Option::is_none")]
457    pub name: Option<String>,
458    #[serde(rename = "shardId")]
459    pub shard_id: i64,
460    #[serde(rename = "isActive")]
461    pub is_active: bool,
462    #[serde(rename = "createdAt")]
463    pub created_at: String,
464    #[serde(rename = "updatedAt")]
465    pub updated_at: String,
466    #[serde(rename = "memberState", skip_serializing_if = "Option::is_none")]
467    pub member_state: Option<String>,
468    #[serde(rename = "copysetId", skip_serializing_if = "Option::is_none")]
469    pub copyset_id: Option<String>,
470}
471
472#[derive(Debug, Clone, Serialize, Deserialize)]
473pub struct Copyset {
474    pub id: String,
475    #[serde(rename = "storageId")]
476    pub storage_id: String,
477    pub name: String,
478    pub state: CopysetState,
479    #[serde(rename = "memberA", skip_serializing_if = "Option::is_none")]
480    pub member_a: Option<String>,
481    #[serde(rename = "memberB", skip_serializing_if = "Option::is_none")]
482    pub member_b: Option<String>,
483    #[serde(rename = "drainStartedAt", skip_serializing_if = "Option::is_none")]
484    pub drain_started_at: Option<String>,
485    #[serde(rename = "syncedAt", skip_serializing_if = "Option::is_none")]
486    pub synced_at: Option<String>,
487    #[serde(rename = "retiredAt", skip_serializing_if = "Option::is_none")]
488    pub retired_at: Option<String>,
489    #[serde(rename = "pendingSyncJobsA", skip_serializing_if = "Option::is_none")]
490    pub pending_sync_jobs_a: Option<i32>,
491    #[serde(rename = "pendingSyncJobsB", skip_serializing_if = "Option::is_none")]
492    pub pending_sync_jobs_b: Option<i32>,
493    #[serde(rename = "pendingSyncJobsObservedAt", skip_serializing_if = "Option::is_none")]
494    pub pending_sync_jobs_observed_at: Option<String>,
495    #[serde(rename = "volumeCount")]
496    pub volume_count: i64,
497    #[serde(rename = "drainInitiatedBy", skip_serializing_if = "Option::is_none")]
498    pub drain_initiated_by: Option<i64>,
499    pub tags: Vec<String>,
500}
501
502#[derive(Debug, Clone, Serialize, Deserialize)]
503pub struct PoolMember {
504    pub id: String,
505    pub name: String,
506    #[serde(rename = "regionId")]
507    pub region_id: i64,
508    #[serde(rename = "memberState")]
509    pub member_state: String,
510}
511
512#[derive(Debug, Clone, Serialize, Deserialize)]
513pub struct Volume {
514    pub id: i64,
515    pub account: Ref,
516    pub storage: Ref,
517    pub region: Ref,
518    #[serde(rename = "metadataCluster", skip_serializing_if = "Option::is_none")]
519    pub metadata_cluster: Option<Ref>,
520    pub name: String,
521    #[serde(skip_serializing_if = "Option::is_none")]
522    pub description: Option<String>,
523    #[serde(rename = "volumeType")]
524    pub volume_type: String,
525    #[serde(rename = "storageType", skip_serializing_if = "Option::is_none")]
526    pub storage_type: Option<String>,
527    pub encryption: bool,
528    #[serde(rename = "quotaLimit")]
529    pub quota_limit: i64,
530    #[serde(rename = "liveVolume")]
531    pub live_volume: i64,
532    #[serde(rename = "totalVolume")]
533    pub total_volume: i64,
534    #[serde(rename = "pendingVolume")]
535    pub pending_volume: i64,
536    #[serde(rename = "liveInactiveVolume")]
537    pub live_inactive_volume: i64,
538    pub locked: bool,
539    pub retention: VolumeRetentionPolicy,
540    pub versioning: VolumeVersioningPolicy,
541    pub compaction: String,
542    #[serde(rename = "isActive")]
543    pub is_active: bool,
544    #[serde(rename = "isCleanupMetaEnabled")]
545    pub is_cleanup_meta_enabled: bool,
546    #[serde(rename = "isCleanupStorageEnabled")]
547    pub is_cleanup_storage_enabled: bool,
548    #[serde(rename = "isCleanupVaultEnabled")]
549    pub is_cleanup_vault_enabled: bool,
550    #[serde(rename = "createdAt")]
551    pub created_at: String,
552    #[serde(rename = "updatedAt")]
553    pub updated_at: String,
554}
555
556#[derive(Debug, Clone, Serialize, Deserialize)]
557pub struct VolumeBlockPlacementConfig {
558    pub id: i64,
559    #[serde(rename = "targetCopysetCount")]
560    pub target_copyset_count: i32,
561    #[serde(rename = "currentEpoch")]
562    pub current_epoch: i64,
563    #[serde(rename = "copysetIds")]
564    pub copyset_ids: Vec<String>,
565}
566
567#[derive(Debug, Clone, Serialize, Deserialize)]
568pub struct VolumeBlockPlacementResizeResult {
569    pub id: i64,
570    #[serde(rename = "targetCopysetCount")]
571    pub target_copyset_count: i32,
572    #[serde(rename = "copysetCountBefore")]
573    pub copyset_count_before: i32,
574    #[serde(rename = "copysetsAdded")]
575    pub copysets_added: i32,
576    #[serde(rename = "copysetsRemoved")]
577    pub copysets_removed: i32,
578    #[serde(rename = "copysetCountAfter")]
579    pub copyset_count_after: i32,
580    pub epoch: i64,
581    pub partial: bool,
582    #[serde(skip_serializing_if = "Option::is_none")]
583    pub reason: Option<String>,
584}
585
586#[derive(Debug, Clone, Serialize, Deserialize)]
587pub struct Fork {
588    pub fid: i32,
589    pub name: String,
590    #[serde(rename = "parentFid")]
591    pub parent_fid: i32,
592    #[serde(rename = "parentName")]
593    pub parent_name: String,
594    #[serde(rename = "snapshotTs")]
595    pub snapshot_ts: i64,
596    #[serde(rename = "createdBy", skip_serializing_if = "Option::is_none")]
597    pub created_by: Option<i64>,
598    #[serde(rename = "createdAt")]
599    pub created_at: i64,
600    #[serde(rename = "childrenCount")]
601    pub children_count: i32,
602    #[serde(skip_serializing_if = "Option::is_none")]
603    pub inactive: Option<bool>,
604    #[serde(rename = "inactiveAt", skip_serializing_if = "Option::is_none")]
605    pub inactive_at: Option<i64>,
606    pub status: String,
607    pub size: i64,
608}
609
610#[derive(Debug, Clone, Serialize, Deserialize)]
611pub struct ForkTreeEntry {
612    pub inode: i64,
613    pub name: String,
614    pub kind: String,
615    pub size: i64,
616    pub mtime: i64,
617    pub ctime: i64,
618    #[serde(rename = "creatorId", skip_serializing_if = "Option::is_none")]
619    pub creator_id: Option<i64>,
620    #[serde(rename = "updaterId", skip_serializing_if = "Option::is_none")]
621    pub updater_id: Option<i64>,
622}
623
624#[derive(Debug, Clone, Serialize, Deserialize)]
625pub struct ForkEntryDetail {
626    pub inode: i64,
627    pub path: String,
628    pub name: String,
629    pub kind: String,
630    pub size: i64,
631    pub mtime: i64,
632    pub ctime: i64,
633    pub generation: i64,
634    #[serde(skip_serializing_if = "Option::is_none")]
635    pub owner: Option<String>,
636    #[serde(skip_serializing_if = "Option::is_none")]
637    pub mode: Option<i32>,
638    #[serde(skip_serializing_if = "Option::is_none")]
639    pub xattrs: Option<serde_json::Value>,
640    #[serde(rename = "creatorId", skip_serializing_if = "Option::is_none")]
641    pub creator_id: Option<i64>,
642    #[serde(rename = "updaterId", skip_serializing_if = "Option::is_none")]
643    pub updater_id: Option<i64>,
644}
645
646#[derive(Debug, Clone, Serialize, Deserialize)]
647pub struct ForkEntryVersion {
648    pub generation: i64,
649    pub size: i64,
650    pub mtime: i64,
651    #[serde(rename = "updaterId", skip_serializing_if = "Option::is_none")]
652    pub updater_id: Option<i64>,
653    #[serde(rename = "contentHash", skip_serializing_if = "Option::is_none")]
654    pub content_hash: Option<String>,
655}
656
657#[derive(Debug, Clone, Serialize, Deserialize)]
658pub struct ForkTreeMatch {
659    pub path: String,
660    pub inode: i64,
661    pub kind: String,
662    pub size: i64,
663    pub mtime: i64,
664}
665
666#[derive(Debug, Clone, Serialize, Deserialize)]
667pub struct AuditLog {
668    pub id: i64,
669    pub title: String,
670    #[serde(skip_serializing_if = "Option::is_none")]
671    pub description: Option<String>,
672    #[serde(skip_serializing_if = "Option::is_none")]
673    pub subject: Option<String>,
674    pub success: bool,
675    #[serde(skip_serializing_if = "Option::is_none")]
676    pub data: Option<serde_json::Value>,
677    #[serde(rename = "createdBy", skip_serializing_if = "Option::is_none")]
678    pub created_by: Option<String>,
679    #[serde(skip_serializing_if = "Option::is_none")]
680    pub node: Option<String>,
681    #[serde(rename = "accountId", skip_serializing_if = "Option::is_none")]
682    pub account_id: Option<i64>,
683    #[serde(rename = "regionId", skip_serializing_if = "Option::is_none")]
684    pub region_id: Option<i64>,
685    #[serde(rename = "metadataClusterId", skip_serializing_if = "Option::is_none")]
686    pub metadata_cluster_id: Option<i64>,
687    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
688    pub created_at: Option<String>,
689    #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")]
690    pub updated_at: Option<String>,
691}
692
693#[derive(Debug, Clone, Serialize, Deserialize)]
694pub struct ServiceNode {
695    pub id: i64,
696    #[serde(rename = "regionId")]
697    pub region_id: i64,
698    #[serde(rename = "metadataClusterId", skip_serializing_if = "Option::is_none")]
699    pub metadata_cluster_id: Option<i64>,
700    #[serde(rename = "serviceType")]
701    pub service_type: String,
702    #[serde(rename = "nodeId")]
703    pub node_id: String,
704    #[serde(rename = "advertiseAddr")]
705    pub advertise_addr: String,
706    #[serde(rename = "rpcAddr", skip_serializing_if = "Option::is_none")]
707    pub rpc_addr: Option<String>,
708    #[serde(skip_serializing_if = "Option::is_none")]
709    pub metadata: Option<serde_json::Value>,
710    #[serde(rename = "metricsEndpoint", skip_serializing_if = "Option::is_none")]
711    pub metrics_endpoint: Option<String>,
712    #[serde(rename = "instanceId", skip_serializing_if = "Option::is_none")]
713    pub instance_id: Option<String>,
714    #[serde(rename = "instanceInfo", skip_serializing_if = "Option::is_none")]
715    pub instance_info: Option<serde_json::Value>,
716    pub status: String,
717    #[serde(rename = "lastHeartbeat", skip_serializing_if = "Option::is_none")]
718    pub last_heartbeat: Option<i64>,
719    #[serde(rename = "isActive")]
720    pub is_active: bool,
721    #[serde(rename = "memUsage", skip_serializing_if = "Option::is_none")]
722    pub mem_usage: Option<f64>,
723    #[serde(rename = "sysLoad", skip_serializing_if = "Option::is_none")]
724    pub sys_load: Option<i64>,
725    #[serde(rename = "binaryVersion", skip_serializing_if = "Option::is_none")]
726    pub binary_version: Option<i32>,
727}
728
729#[derive(Debug, Clone, Serialize, Deserialize)]
730pub struct ClientSession {
731    pub id: i64,
732    pub account: Ref,
733    pub region: Ref,
734    #[serde(rename = "metadataCluster", skip_serializing_if = "Option::is_none")]
735    pub metadata_cluster: Option<Ref>,
736    pub volume: VolumeRef,
737    #[serde(skip_serializing_if = "Option::is_none")]
738    pub user: Option<Ref>,
739    #[serde(rename = "clientType")]
740    pub client_type: String,
741    #[serde(rename = "osName")]
742    pub os_name: String,
743    #[serde(rename = "osVersion", skip_serializing_if = "Option::is_none")]
744    pub os_version: Option<String>,
745    #[serde(rename = "appVersion", skip_serializing_if = "Option::is_none")]
746    pub app_version: Option<String>,
747    #[serde(skip_serializing_if = "Option::is_none")]
748    pub hostname: Option<String>,
749    #[serde(rename = "ipAddr")]
750    pub ip_addr: String,
751    #[serde(rename = "mountMode", skip_serializing_if = "Option::is_none")]
752    pub mount_mode: Option<String>,
753    #[serde(rename = "mountPath", skip_serializing_if = "Option::is_none")]
754    pub mount_path: Option<String>,
755    #[serde(rename = "forkName", skip_serializing_if = "Option::is_none")]
756    pub fork_name: Option<String>,
757    #[serde(rename = "isTemporaryFork")]
758    pub is_temporary_fork: bool,
759    #[serde(skip_serializing_if = "Option::is_none")]
760    pub metadata: Option<serde_json::Value>,
761    #[serde(skip_serializing_if = "Option::is_none")]
762    pub metrics: Option<serde_json::Value>,
763    pub status: ClientSessionStatus,
764    #[serde(rename = "lastHeartbeat", skip_serializing_if = "Option::is_none")]
765    pub last_heartbeat: Option<i64>,
766    #[serde(rename = "connectedAt", skip_serializing_if = "Option::is_none")]
767    pub connected_at: Option<i64>,
768    #[serde(rename = "disconnectedAt", skip_serializing_if = "Option::is_none")]
769    pub disconnected_at: Option<i64>,
770    #[serde(rename = "isActive")]
771    pub is_active: bool,
772}
773
774#[derive(Debug, Clone, Serialize, Deserialize)]
775pub struct SessionSummary {
776    #[serde(rename = "byStatus")]
777    pub by_status: Vec<SessionSummaryStatusEntry>,
778    #[serde(rename = "byPlatform")]
779    pub by_platform: Vec<SessionSummaryFacet>,
780    #[serde(rename = "byOsName")]
781    pub by_os_name: Vec<SessionSummaryFacet>,
782    #[serde(rename = "regionCount")]
783    pub region_count: i64,
784    #[serde(rename = "volumeCount")]
785    pub volume_count: i64,
786    #[serde(rename = "hostCount")]
787    pub host_count: i64,
788    #[serde(rename = "degradedCount")]
789    pub degraded_count: i64,
790}
791
792#[derive(Debug, Clone, Serialize, Deserialize)]
793pub struct DiscoverMetaResponse {
794    #[serde(rename = "regionId")]
795    pub region_id: i64,
796    pub region: String,
797    pub endpoints: Vec<DiscoverEndpoint>,
798}
799
800#[derive(Debug, Clone, Serialize, Deserialize)]
801pub struct MetricsTarget {
802    pub targets: Vec<String>,
803    pub labels: serde_json::Value,
804}
805
806#[derive(Debug, Clone, Serialize, Deserialize)]
807pub struct MetricsTokenResponse {
808    pub token: String,
809}
810
811#[derive(Debug, Clone, Serialize, Deserialize)]
812pub struct DashboardStats {
813    #[serde(rename = "userCount")]
814    pub user_count: i64,
815    #[serde(rename = "volumeCount")]
816    pub volume_count: i64,
817    #[serde(rename = "regionCount")]
818    pub region_count: i64,
819    #[serde(rename = "storageCount")]
820    pub storage_count: i64,
821    #[serde(rename = "totalVolumeUsed")]
822    pub total_volume_used: i64,
823    #[serde(rename = "totalQuotaLimit")]
824    pub total_quota_limit: i64,
825    #[serde(rename = "activeSessionCount")]
826    pub active_session_count: i64,
827    #[serde(rename = "regionBreakdown")]
828    pub region_breakdown: Vec<RegionVolumeMetrics>,
829}
830
831#[derive(Debug, Clone, Serialize, Deserialize)]
832pub struct LicenseDetails {
833    #[serde(rename = "licenseId")]
834    pub license_id: String,
835    pub licensee: String,
836    pub contact: String,
837    #[serde(rename = "licenseType")]
838    pub license_type: String,
839    #[serde(rename = "issuedAt")]
840    pub issued_at: String,
841    #[serde(rename = "expiresAt")]
842    pub expires_at: String,
843    #[serde(rename = "gracePeriodDays")]
844    pub grace_period_days: i64,
845    #[serde(rename = "expiredAccessDays")]
846    pub expired_access_days: i64,
847    #[serde(rename = "maxNodes")]
848    pub max_nodes: i64,
849    #[serde(rename = "maxVolumes")]
850    pub max_volumes: i64,
851    #[serde(rename = "maxUsers")]
852    pub max_users: i64,
853    #[serde(rename = "maxAccounts")]
854    pub max_accounts: i64,
855    #[serde(rename = "maxRegions")]
856    pub max_regions: i64,
857    #[serde(rename = "maxStorageBytes")]
858    pub max_storage_bytes: i64,
859    pub status: LicenseStatus,
860    #[serde(rename = "daysRemaining")]
861    pub days_remaining: i64,
862    #[serde(rename = "graceEndsAt")]
863    pub grace_ends_at: String,
864    #[serde(rename = "graceDaysLeft")]
865    pub grace_days_left: i64,
866    #[serde(rename = "expiredAccessEndsAt")]
867    pub expired_access_ends_at: String,
868    #[serde(rename = "expiredAccessDaysLeft")]
869    pub expired_access_days_left: i64,
870    pub quota: LicenseQuota,
871    #[serde(skip_serializing_if = "Option::is_none")]
872    pub distribution: Option<String>,
873    #[serde(rename = "distributionRef", skip_serializing_if = "Option::is_none")]
874    pub distribution_ref: Option<Vec<String>>,
875    #[serde(rename = "unlimitedStorage", skip_serializing_if = "Option::is_none")]
876    pub unlimited_storage: Option<bool>,
877}
878
879#[derive(Debug, Clone, Serialize, Deserialize)]
880pub struct LicenseTerms {
881    pub terms: String,
882}
883
884#[derive(Debug, Clone, Serialize, Deserialize)]
885pub struct LicenseLoadResult {
886    pub loaded: i64,
887    pub ignored: i64,
888}
889
890#[derive(Debug, Clone, Serialize, Deserialize)]
891pub struct LicenseList {
892    pub items: Vec<LicenseRecord>,
893}
894
895#[derive(Debug, Clone, Serialize, Deserialize)]
896pub struct ServiceAlert {
897    pub id: i64,
898    #[serde(rename = "alertId")]
899    pub alert_id: String,
900    pub source: String,
901    #[serde(rename = "nodeId")]
902    pub node_id: String,
903    pub severity: i64,
904    pub category: String,
905    pub title: String,
906    #[serde(skip_serializing_if = "Option::is_none")]
907    pub description: Option<String>,
908    #[serde(skip_serializing_if = "Option::is_none")]
909    pub region: Option<Ref>,
910    #[serde(skip_serializing_if = "Option::is_none")]
911    pub account: Option<Ref>,
912    #[serde(rename = "eventTime")]
913    pub event_time: String,
914    #[serde(rename = "resolvedAt", skip_serializing_if = "Option::is_none")]
915    pub resolved_at: Option<String>,
916    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
917    pub created_at: Option<String>,
918}
919
920#[derive(Debug, Clone, Serialize, Deserialize)]
921pub struct AlertCountResponse {
922    pub active: i64,
923    pub recent: i64,
924    #[serde(rename = "infoCount")]
925    pub info_count: i64,
926    #[serde(rename = "warningCount")]
927    pub warning_count: i64,
928    #[serde(rename = "criticalCount")]
929    pub critical_count: i64,
930    #[serde(rename = "asOf")]
931    pub as_of: String,
932}
933
934#[derive(Debug, Clone, Serialize, Deserialize)]
935pub struct RegionAlert {
936    pub id: i64,
937    #[serde(rename = "alertId")]
938    pub alert_id: String,
939    pub source: String,
940    #[serde(rename = "nodeId")]
941    pub node_id: String,
942    #[serde(rename = "metadataClusterId", skip_serializing_if = "Option::is_none")]
943    pub metadata_cluster_id: Option<i64>,
944    pub severity: i64,
945    pub category: String,
946    pub title: String,
947    #[serde(skip_serializing_if = "Option::is_none")]
948    pub description: Option<String>,
949    #[serde(rename = "eventTime")]
950    pub event_time: String,
951    #[serde(rename = "resolvedAt", skip_serializing_if = "Option::is_none")]
952    pub resolved_at: Option<String>,
953    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
954    pub created_at: Option<String>,
955}
956
957#[derive(Debug, Clone, Serialize, Deserialize)]
958pub struct GCWorkerEvent {
959    pub id: i64,
960    #[serde(rename = "nodeId")]
961    pub node_id: String,
962    #[serde(rename = "metadataClusterId", skip_serializing_if = "Option::is_none")]
963    pub metadata_cluster_id: Option<i64>,
964    pub goal: String,
965    #[serde(skip_serializing_if = "Option::is_none")]
966    pub sid: Option<i64>,
967    #[serde(skip_serializing_if = "Option::is_none")]
968    pub subject: Option<String>,
969    pub ops: serde_json::Value,
970    #[serde(rename = "durationMs")]
971    pub duration_ms: i64,
972    #[serde(rename = "eventTime")]
973    pub event_time: String,
974    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
975    pub created_at: Option<String>,
976}
977
978#[derive(Debug, Clone, Serialize, Deserialize)]
979pub struct GCWorkerEventHistogramResponse {
980    pub buckets: Vec<GCWorkerEventBucket>,
981}
982
983#[derive(Debug, Clone, Serialize, Deserialize)]
984pub struct GCWorkerEventGoalsResponse {
985    pub goals: Vec<String>,
986}
987
988#[derive(Debug, Clone, Serialize, Deserialize)]
989pub struct BackfillFailure {
990    #[serde(rename = "shardId")]
991    pub shard_id: i64,
992    pub error: String,
993}
994
995#[derive(Debug, Clone, Serialize, Deserialize)]
996pub struct CompatibleStorage {
997    pub id: i64,
998    pub uuid: String,
999    pub name: String,
1000    #[serde(rename = "storageType")]
1001    pub storage_type: String,
1002    #[serde(rename = "providerType")]
1003    pub provider_type: String,
1004    pub volumes: Vec<CompatibleVolume>,
1005}
1006
1007#[derive(Debug, Clone, Serialize, Deserialize)]
1008pub struct CompatibleVolume {
1009    pub id: String,
1010    pub name: String,
1011}
1012
1013#[derive(Debug, Clone, Serialize, Deserialize)]
1014pub struct DashboardUser {
1015    pub id: String,
1016    pub name: String,
1017    #[serde(skip_serializing_if = "Option::is_none")]
1018    pub email: Option<String>,
1019    pub role: String,
1020    #[serde(skip_serializing_if = "Option::is_none")]
1021    pub username: Option<String>,
1022    #[serde(rename = "accountId", skip_serializing_if = "Option::is_none")]
1023    pub account_id: Option<i64>,
1024    #[serde(rename = "userId", skip_serializing_if = "Option::is_none")]
1025    pub user_id: Option<i64>,
1026    #[serde(rename = "volumeId", skip_serializing_if = "Option::is_none")]
1027    pub volume_id: Option<i64>,
1028    #[serde(skip_serializing_if = "Option::is_none")]
1029    pub exp: Option<i64>,
1030}
1031
1032#[derive(Debug, Clone, Serialize, Deserialize)]
1033pub struct DiscoverEndpoint {
1034    #[serde(rename = "nodeId")]
1035    pub node_id: String,
1036    pub addr: String,
1037    pub status: String,
1038}
1039
1040#[derive(Debug, Clone, Serialize, Deserialize)]
1041pub struct GCWorkerEventBucket {
1042    #[serde(rename = "bucketStart")]
1043    pub bucket_start: String,
1044    pub goal: String,
1045    pub count: i64,
1046}
1047
1048#[derive(Debug, Clone, Serialize, Deserialize)]
1049pub struct LicenseQuota {
1050    pub state: LicenseQuotaState,
1051    #[serde(rename = "liveVolume")]
1052    pub live_volume: i64,
1053    #[serde(rename = "totalVolume")]
1054    pub total_volume: i64,
1055    pub generation: i64,
1056    #[serde(rename = "lastTransitionAtMs")]
1057    pub last_transition_at_ms: i64,
1058}
1059
1060#[derive(Debug, Clone, Serialize, Deserialize)]
1061pub struct LicenseRecord {
1062    pub key: String,
1063    pub licensee: String,
1064    pub status: LicenseStatus,
1065    #[serde(rename = "issuedAt")]
1066    pub issued_at: String,
1067    #[serde(rename = "expiresAt")]
1068    pub expires_at: String,
1069    #[serde(rename = "maxStorageBytes")]
1070    pub max_storage_bytes: i64,
1071    #[serde(rename = "insertedAt")]
1072    pub inserted_at: String,
1073}
1074
1075#[derive(Debug, Clone, Serialize, Deserialize)]
1076pub struct MoveVolumeFailure {
1077    #[serde(rename = "volumeId")]
1078    pub volume_id: String,
1079    pub error: String,
1080}
1081
1082#[derive(Debug, Clone, Serialize, Deserialize)]
1083pub struct NodeStatsSample {
1084    #[serde(rename = "timestampMs")]
1085    pub timestamp_ms: i64,
1086    #[serde(rename = "intervalMs")]
1087    pub interval_ms: i64,
1088    #[serde(rename = "loadAvg1")]
1089    pub load_avg1: f64,
1090    #[serde(rename = "loadAvg5")]
1091    pub load_avg5: f64,
1092    #[serde(rename = "loadAvg15")]
1093    pub load_avg15: f64,
1094    #[serde(rename = "memUsage")]
1095    pub mem_usage: f64,
1096    #[serde(rename = "readIops")]
1097    pub read_iops: f64,
1098    #[serde(rename = "writeIops")]
1099    pub write_iops: f64,
1100    #[serde(rename = "netRxBytesPerSec")]
1101    pub net_rx_bytes_per_sec: f64,
1102    #[serde(rename = "netTxBytesPerSec")]
1103    pub net_tx_bytes_per_sec: f64,
1104    #[serde(rename = "processCount")]
1105    pub process_count: i64,
1106    #[serde(rename = "diskUsedBytes", skip_serializing_if = "Option::is_none")]
1107    pub disk_used_bytes: Option<i64>,
1108    #[serde(rename = "diskTotalBytes", skip_serializing_if = "Option::is_none")]
1109    pub disk_total_bytes: Option<i64>,
1110    #[serde(rename = "dbLatency1mUs", skip_serializing_if = "Option::is_none")]
1111    pub db_latency1m_us: Option<f64>,
1112    #[serde(rename = "dbLatency5mUs", skip_serializing_if = "Option::is_none")]
1113    pub db_latency5m_us: Option<f64>,
1114    #[serde(rename = "dbLatency15mUs", skip_serializing_if = "Option::is_none")]
1115    pub db_latency15m_us: Option<f64>,
1116    #[serde(rename = "dbQueriesPerSec", skip_serializing_if = "Option::is_none")]
1117    pub db_queries_per_sec: Option<f64>,
1118    #[serde(rename = "dbConnsInUse", skip_serializing_if = "Option::is_none")]
1119    pub db_conns_in_use: Option<i64>,
1120    #[serde(rename = "dbConnsMax", skip_serializing_if = "Option::is_none")]
1121    pub db_conns_max: Option<i64>,
1122    #[serde(rename = "dbConnsIdle", skip_serializing_if = "Option::is_none")]
1123    pub db_conns_idle: Option<i64>,
1124    #[serde(rename = "dbConnsFree", skip_serializing_if = "Option::is_none")]
1125    pub db_conns_free: Option<i64>,
1126    #[serde(rename = "dbConnsInUse1m", skip_serializing_if = "Option::is_none")]
1127    pub db_conns_in_use1m: Option<f64>,
1128    #[serde(rename = "dbConnsInUse5m", skip_serializing_if = "Option::is_none")]
1129    pub db_conns_in_use5m: Option<f64>,
1130    #[serde(rename = "dbConnsInUse15m", skip_serializing_if = "Option::is_none")]
1131    pub db_conns_in_use15m: Option<f64>,
1132    #[serde(rename = "dbPingAvgUs", skip_serializing_if = "Option::is_none")]
1133    pub db_ping_avg_us: Option<f64>,
1134    #[serde(rename = "dbPingMinUs", skip_serializing_if = "Option::is_none")]
1135    pub db_ping_min_us: Option<f64>,
1136    #[serde(rename = "dbPingMaxUs", skip_serializing_if = "Option::is_none")]
1137    pub db_ping_max_us: Option<f64>,
1138    #[serde(rename = "dbPingStdDevUs", skip_serializing_if = "Option::is_none")]
1139    pub db_ping_std_dev_us: Option<f64>,
1140    #[serde(rename = "dbDispatchOutstanding", skip_serializing_if = "Option::is_none")]
1141    pub db_dispatch_outstanding: Option<i64>,
1142    #[serde(rename = "dbDispatchLaneCap", skip_serializing_if = "Option::is_none")]
1143    pub db_dispatch_lane_cap: Option<i64>,
1144}
1145
1146#[derive(Debug, Clone, Serialize, Deserialize)]
1147pub struct Ref {
1148    pub id: i64,
1149    pub name: String,
1150}
1151
1152#[derive(Debug, Clone, Serialize, Deserialize)]
1153pub struct RegionVolumeMetrics {
1154    #[serde(rename = "regionId")]
1155    pub region_id: i64,
1156    #[serde(rename = "regionName")]
1157    pub region_name: String,
1158    #[serde(rename = "volumeCount")]
1159    pub volume_count: i64,
1160    #[serde(rename = "totalVolumeUsed")]
1161    pub total_volume_used: i64,
1162    #[serde(rename = "totalQuotaLimit")]
1163    pub total_quota_limit: i64,
1164}
1165
1166#[derive(Debug, Clone, Serialize, Deserialize)]
1167pub struct RetentionPolicy {
1168    #[serde(rename = "clientSessionDays", skip_serializing_if = "Option::is_none")]
1169    pub client_session_days: Option<i32>,
1170}
1171
1172#[derive(Debug, Clone, Serialize, Deserialize)]
1173pub struct SessionSummaryFacet {
1174    pub label: String,
1175    pub count: i64,
1176}
1177
1178#[derive(Debug, Clone, Serialize, Deserialize)]
1179pub struct SessionSummaryStatusEntry {
1180    #[serde(rename = "clientType")]
1181    pub client_type: String,
1182    pub status: String,
1183    pub count: i64,
1184}
1185
1186#[derive(Debug, Clone, Serialize, Deserialize)]
1187pub struct UserLite {
1188    pub id: i64,
1189    pub username: String,
1190    pub name: String,
1191}
1192
1193#[derive(Debug, Clone, Serialize, Deserialize)]
1194pub struct VolumeApiKey {
1195    #[serde(rename = "apiKey")]
1196    pub api_key: String,
1197    #[serde(skip_serializing_if = "Option::is_none")]
1198    pub name: Option<String>,
1199    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
1200    pub created_at: Option<String>,
1201    #[serde(rename = "lastUsedAt", skip_serializing_if = "Option::is_none")]
1202    pub last_used_at: Option<String>,
1203}
1204
1205#[derive(Debug, Clone, Serialize, Deserialize)]
1206pub struct VolumeRef {
1207    pub id: i64,
1208    pub name: String,
1209    #[serde(skip_serializing_if = "Option::is_none")]
1210    pub r#type: Option<String>,
1211}
1212
1213#[derive(Debug, Clone, Serialize, Deserialize)]
1214pub struct VolumeRetentionPolicy {
1215    #[serde(rename = "dataDays", skip_serializing_if = "Option::is_none")]
1216    pub data_days: Option<i32>,
1217    #[serde(rename = "graceDays", skip_serializing_if = "Option::is_none")]
1218    pub grace_days: Option<i32>,
1219    #[serde(rename = "forkGraceDays", skip_serializing_if = "Option::is_none")]
1220    pub fork_grace_days: Option<i32>,
1221    #[serde(rename = "eventLogDays", skip_serializing_if = "Option::is_none")]
1222    pub event_log_days: Option<i32>,
1223}
1224
1225#[derive(Debug, Clone, Serialize, Deserialize)]
1226pub struct VolumeSizePoint {
1227    #[serde(rename = "bucketEnd")]
1228    pub bucket_end: String,
1229    #[serde(rename = "liveVolume")]
1230    pub live_volume: i64,
1231    #[serde(rename = "totalVolume")]
1232    pub total_volume: i64,
1233    #[serde(rename = "pendingVolume")]
1234    pub pending_volume: i64,
1235    #[serde(rename = "liveInactiveVolume")]
1236    pub live_inactive_volume: i64,
1237}
1238
1239#[derive(Debug, Clone, Serialize, Deserialize)]
1240pub struct VolumeVersioningPolicy {
1241    #[serde(rename = "contentWindowSeconds", skip_serializing_if = "Option::is_none")]
1242    pub content_window_seconds: Option<i32>,
1243}
1244
1245// Accounts
1246
1247#[derive(Debug, Clone, Serialize)]
1248pub struct CreateAccountRequest {
1249    pub name: String,
1250    #[serde(skip_serializing_if = "Option::is_none")]
1251    pub description: Option<String>,
1252    #[serde(rename = "iconUrl", skip_serializing_if = "Option::is_none")]
1253    pub icon_url: Option<String>,
1254    #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
1255    pub provider_info: Option<serde_json::Value>,
1256}
1257
1258#[derive(Debug, Clone, Serialize)]
1259pub struct EditAccountRequest {
1260    pub name: String,
1261    #[serde(skip_serializing_if = "Option::is_none")]
1262    pub description: Option<String>,
1263    #[serde(rename = "iconUrl", skip_serializing_if = "Option::is_none")]
1264    pub icon_url: Option<String>,
1265    #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
1266    pub provider_info: Option<serde_json::Value>,
1267    #[serde(skip_serializing_if = "Option::is_none")]
1268    pub retention: Option<RetentionPolicy>,
1269}
1270
1271#[derive(Debug, Clone, Serialize)]
1272pub struct UpdateAccountQuotaRequest {
1273    #[serde(rename = "quotaLimit")]
1274    pub quota_limit: i64,
1275    #[serde(rename = "quotaExcessPct", skip_serializing_if = "Option::is_none")]
1276    pub quota_excess_pct: Option<i32>,
1277}
1278
1279#[derive(Debug, Clone, Default)]
1280pub struct AccountListOptions {
1281    pub is_active: Option<bool>,
1282    pub page: Option<i64>,
1283    pub limit: Option<i64>,
1284}
1285
1286// Users
1287
1288#[derive(Debug, Clone, Serialize)]
1289pub struct AddUserRequest {
1290    #[serde(rename = "accountId")]
1291    pub account_id: i64,
1292    pub username: String,
1293    pub email: String,
1294    #[serde(skip_serializing_if = "Option::is_none")]
1295    pub name: Option<String>,
1296    #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
1297    pub provider_info: Option<serde_json::Value>,
1298}
1299
1300#[derive(Debug, Clone, Serialize)]
1301pub struct BulkUserRequest {
1302    pub ids: Vec<i64>,
1303}
1304
1305#[derive(Debug, Clone, Serialize, Deserialize)]
1306pub struct BulkUserResponse {
1307    pub users: Vec<UserLite>,
1308}
1309
1310#[derive(Debug, Clone, Serialize)]
1311pub struct EditUserRequest {
1312    pub username: String,
1313    pub email: String,
1314    #[serde(skip_serializing_if = "Option::is_none")]
1315    pub name: Option<String>,
1316    #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
1317    pub provider_info: Option<serde_json::Value>,
1318}
1319
1320#[derive(Debug, Clone, Default)]
1321pub struct UserListOptions {
1322    pub account_id: i64,
1323    pub search: Option<String>,
1324    pub is_active: Option<bool>,
1325    pub page: Option<i64>,
1326    pub limit: Option<i64>,
1327}
1328
1329// Regions
1330
1331#[derive(Debug, Clone, Serialize)]
1332pub struct CreateRegionRequest {
1333    #[serde(rename = "accountId")]
1334    pub account_id: i64,
1335    pub name: String,
1336}
1337
1338#[derive(Debug, Clone, Serialize)]
1339pub struct EditRegionRequest {
1340    #[serde(rename = "accountId")]
1341    pub account_id: i64,
1342    pub name: String,
1343}
1344
1345#[derive(Debug, Clone, Default)]
1346pub struct RegionListOptions {
1347    pub account_id: i64,
1348    pub is_active: Option<bool>,
1349    pub page: Option<i64>,
1350    pub limit: Option<i64>,
1351}
1352
1353// Clusters
1354
1355#[derive(Debug, Clone, Default)]
1356pub struct ClusterListOptions {
1357    pub account_id: i64,
1358    pub region_id: Option<i64>,
1359    pub is_active: Option<bool>,
1360    pub page: Option<i64>,
1361    pub limit: Option<i64>,
1362}
1363
1364// MetadataClusters
1365
1366#[derive(Debug, Clone, Serialize)]
1367pub struct CreateMetadataClusterRequest {
1368    pub name: String,
1369}
1370
1371#[derive(Debug, Clone, Serialize)]
1372pub struct EditMetadataClusterRequest {
1373    pub name: String,
1374}
1375
1376#[derive(Debug, Clone, Serialize)]
1377pub struct SetMetadataClusterReadyRequest {
1378    pub ready: bool,
1379}
1380
1381#[derive(Debug, Clone, Serialize, Deserialize)]
1382pub struct SetReadyMetadataClusterResponse {
1383    pub id: i64,
1384    pub ready: bool,
1385}
1386
1387#[derive(Debug, Clone, Default)]
1388pub struct MetadataClusterListOptions {
1389    pub is_active: Option<bool>,
1390    pub page: Option<i64>,
1391    pub limit: Option<i64>,
1392}
1393
1394// Storages
1395
1396#[derive(Debug, Clone, Serialize)]
1397pub struct CreateStorageRequest {
1398    #[serde(rename = "accountId")]
1399    pub account_id: i64,
1400    #[serde(rename = "regionId")]
1401    pub region_id: i64,
1402    pub name: String,
1403    #[serde(skip_serializing_if = "Option::is_none")]
1404    pub description: Option<String>,
1405    #[serde(rename = "storageType")]
1406    pub storage_type: String,
1407    #[serde(rename = "providerType")]
1408    pub provider_type: String,
1409    pub endpoint: String,
1410    #[serde(skip_serializing_if = "Option::is_none")]
1411    pub region: Option<String>,
1412    #[serde(skip_serializing_if = "Option::is_none")]
1413    pub bucket: Option<String>,
1414    #[serde(skip_serializing_if = "Option::is_none")]
1415    pub base: Option<String>,
1416    #[serde(rename = "blockRegion", skip_serializing_if = "Option::is_none")]
1417    pub block_region: Option<String>,
1418    #[serde(rename = "blockSize", skip_serializing_if = "Option::is_none")]
1419    pub block_size: Option<i32>,
1420    #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none")]
1421    pub access_key: Option<String>,
1422    #[serde(rename = "secretKey", skip_serializing_if = "Option::is_none")]
1423    pub secret_key: Option<String>,
1424}
1425
1426#[derive(Debug, Clone, Serialize)]
1427pub struct EditStorageRequest {
1428    pub name: String,
1429    #[serde(skip_serializing_if = "Option::is_none")]
1430    pub description: Option<String>,
1431    #[serde(skip_serializing_if = "Option::is_none")]
1432    pub endpoint: Option<String>,
1433    #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none")]
1434    pub access_key: Option<String>,
1435    #[serde(rename = "secretKey", skip_serializing_if = "Option::is_none")]
1436    pub secret_key: Option<String>,
1437    #[serde(rename = "directAccess", skip_serializing_if = "Option::is_none")]
1438    pub direct_access: Option<bool>,
1439}
1440
1441#[derive(Debug, Clone, Serialize)]
1442pub struct TestStorageNewBucketRequest {
1443    pub endpoint: String,
1444    #[serde(skip_serializing_if = "Option::is_none")]
1445    pub region: Option<String>,
1446    pub bucket: String,
1447    #[serde(rename = "accessKey")]
1448    pub access_key: String,
1449    #[serde(rename = "secretKey")]
1450    pub secret_key: String,
1451    #[serde(rename = "providerType", skip_serializing_if = "Option::is_none")]
1452    pub provider_type: Option<String>,
1453}
1454
1455#[derive(Debug, Clone, Serialize, Deserialize)]
1456pub struct TestNewBucketStorageResponse {
1457    #[serde(rename = "bucketExists")]
1458    pub bucket_exists: bool,
1459    pub list: bool,
1460    pub write: bool,
1461    pub read: bool,
1462    pub delete: bool,
1463    pub multipart: bool,
1464}
1465
1466#[derive(Debug, Clone, Serialize, Deserialize)]
1467pub struct TestStorageBucketStorageResponse {
1468    #[serde(rename = "bucketExists")]
1469    pub bucket_exists: bool,
1470    pub list: bool,
1471    pub write: bool,
1472    pub read: bool,
1473    pub delete: bool,
1474    pub multipart: bool,
1475}
1476
1477#[derive(Debug, Clone, Serialize, Deserialize)]
1478pub struct ListCompatibleStorageResponse {
1479    pub storages: Vec<CompatibleStorage>,
1480}
1481
1482#[derive(Debug, Clone, Serialize)]
1483pub struct MoveStorageVolumesRequest {
1484    #[serde(rename = "volumeIds")]
1485    pub volume_ids: Vec<String>,
1486}
1487
1488#[derive(Debug, Clone, Serialize, Deserialize)]
1489pub struct MoveVolumesStorageResponse {
1490    pub moved: Vec<String>,
1491    pub failures: Vec<MoveVolumeFailure>,
1492}
1493
1494#[derive(Debug, Clone, Serialize, Deserialize)]
1495pub struct DrainCopysetStorageResponse {
1496    pub id: String,
1497    pub state: String,
1498}
1499
1500#[derive(Debug, Clone, Serialize, Deserialize)]
1501pub struct CancelDrainStorageResponse {
1502    pub id: String,
1503    pub state: String,
1504}
1505
1506#[derive(Debug, Clone, Serialize)]
1507pub struct UpdateStorageTagsRequest {
1508    #[serde(skip_serializing_if = "Option::is_none")]
1509    pub tags: Option<Vec<String>>,
1510}
1511
1512#[derive(Debug, Clone, Serialize)]
1513pub struct RegisterStorageCopysetRequest {
1514    #[serde(skip_serializing_if = "Option::is_none")]
1515    pub name: Option<String>,
1516}
1517
1518#[derive(Debug, Clone, Serialize)]
1519pub struct RegisterStorageCopysetsBulkRequest {
1520    pub count: i32,
1521}
1522
1523#[derive(Debug, Clone, Serialize, Deserialize)]
1524pub struct RegisterCopysetsBulkStorageResponse {
1525    pub copysets: Vec<Copyset>,
1526}
1527
1528#[derive(Debug, Clone, Serialize, Deserialize)]
1529pub struct RemoveMemberStorageResponse {
1530    pub id: String,
1531}
1532
1533#[derive(Debug, Clone, Serialize, Deserialize)]
1534pub struct BackfillFingerprintsStorageResponse {
1535    pub scanned: i32,
1536    pub updated: i32,
1537    pub failures: Vec<BackfillFailure>,
1538    #[serde(rename = "hasMore")]
1539    pub has_more: bool,
1540}
1541
1542#[derive(Debug, Clone, Default)]
1543pub struct StorageListOptions {
1544    pub account_id: i64,
1545    pub search: Option<String>,
1546    pub region_id: Option<i64>,
1547    pub storage_type: Option<String>,
1548    pub provider_type: Option<String>,
1549    pub is_active: Option<bool>,
1550    pub direct_access: Option<bool>,
1551    pub page: Option<i64>,
1552    pub limit: Option<i64>,
1553}
1554
1555// Volumes
1556
1557#[derive(Debug, Clone, Serialize)]
1558pub struct CreateVolumeRequest {
1559    #[serde(rename = "accountId")]
1560    pub account_id: i64,
1561    #[serde(rename = "storageId")]
1562    pub storage_id: i64,
1563    pub name: String,
1564    #[serde(skip_serializing_if = "Option::is_none")]
1565    pub description: Option<String>,
1566    #[serde(rename = "volumeType")]
1567    pub volume_type: String,
1568    #[serde(skip_serializing_if = "Option::is_none")]
1569    pub encryption: Option<bool>,
1570    #[serde(rename = "encryptionKey", skip_serializing_if = "Option::is_none")]
1571    pub encryption_key: Option<String>,
1572    #[serde(skip_serializing_if = "Option::is_none")]
1573    pub retention: Option<VolumeRetentionPolicy>,
1574    #[serde(skip_serializing_if = "Option::is_none")]
1575    pub versioning: Option<VolumeVersioningPolicy>,
1576    #[serde(skip_serializing_if = "Option::is_none")]
1577    pub compaction: Option<String>,
1578    #[serde(rename = "quotaLimit", skip_serializing_if = "Option::is_none")]
1579    pub quota_limit: Option<i64>,
1580    #[serde(rename = "metadataClusterId", skip_serializing_if = "Option::is_none")]
1581    pub metadata_cluster_id: Option<i64>,
1582    #[serde(rename = "metadataClusterUuid", skip_serializing_if = "Option::is_none")]
1583    pub metadata_cluster_uuid: Option<String>,
1584}
1585
1586#[derive(Debug, Clone, Serialize, Deserialize)]
1587pub struct CreateVolumeResponse {
1588    pub id: i64,
1589    #[serde(rename = "encryptionKey", skip_serializing_if = "Option::is_none")]
1590    pub encryption_key: Option<String>,
1591}
1592
1593#[derive(Debug, Clone, Serialize)]
1594pub struct EditVolumeRequest {
1595    #[serde(skip_serializing_if = "Option::is_none")]
1596    pub description: Option<String>,
1597    #[serde(skip_serializing_if = "Option::is_none")]
1598    pub retention: Option<VolumeRetentionPolicy>,
1599    #[serde(skip_serializing_if = "Option::is_none")]
1600    pub versioning: Option<VolumeVersioningPolicy>,
1601    #[serde(skip_serializing_if = "Option::is_none")]
1602    pub compaction: Option<String>,
1603}
1604
1605#[derive(Debug, Clone, Serialize)]
1606pub struct MoveVolumeClusterRequest {
1607    #[serde(rename = "targetClusterId", skip_serializing_if = "Option::is_none")]
1608    pub target_cluster_id: Option<i64>,
1609    #[serde(rename = "targetClusterUuid", skip_serializing_if = "Option::is_none")]
1610    pub target_cluster_uuid: Option<String>,
1611}
1612
1613#[derive(Debug, Clone, Serialize, Deserialize)]
1614pub struct MoveClusterVolumeResponse {
1615    pub id: i64,
1616    #[serde(rename = "sourceClusterId")]
1617    pub source_cluster_id: i64,
1618    #[serde(rename = "targetClusterId")]
1619    pub target_cluster_id: i64,
1620    #[serde(rename = "handoverUntil")]
1621    pub handover_until: i64,
1622}
1623
1624#[derive(Debug, Clone, Serialize)]
1625pub struct DeactivateVolumeRequest {
1626    #[serde(rename = "isCleanupMetaEnabled", skip_serializing_if = "Option::is_none")]
1627    pub is_cleanup_meta_enabled: Option<bool>,
1628    #[serde(rename = "isCleanupStorageEnabled", skip_serializing_if = "Option::is_none")]
1629    pub is_cleanup_storage_enabled: Option<bool>,
1630    #[serde(rename = "isCleanupVaultEnabled", skip_serializing_if = "Option::is_none")]
1631    pub is_cleanup_vault_enabled: Option<bool>,
1632}
1633
1634#[derive(Debug, Clone, Serialize)]
1635pub struct GenerateVolumeAPIKeysRequest {
1636    #[serde(rename = "userId")]
1637    pub user_id: i64,
1638    #[serde(skip_serializing_if = "Option::is_none")]
1639    pub name: Option<String>,
1640}
1641
1642#[derive(Debug, Clone, Serialize, Deserialize)]
1643pub struct GenerateAPIKeysVolumeResponse {
1644    #[serde(rename = "apiKey")]
1645    pub api_key: String,
1646    #[serde(rename = "apiSecret")]
1647    pub api_secret: String,
1648    #[serde(rename = "evictedApiKeys", skip_serializing_if = "Option::is_none")]
1649    pub evicted_api_keys: Option<Vec<String>>,
1650}
1651
1652#[derive(Debug, Clone, Serialize, Deserialize)]
1653pub struct ListAPIKeysVolumeResponse {
1654    pub keys: Vec<VolumeApiKey>,
1655}
1656
1657#[derive(Debug, Clone, Serialize)]
1658pub struct RevokeVolumeAPIKeyRequest {
1659    #[serde(rename = "apiKey")]
1660    pub api_key: String,
1661}
1662
1663#[derive(Debug, Clone, Serialize)]
1664pub struct RevokeVolumeAPIKeysByUserRequest {
1665    #[serde(rename = "userId")]
1666    pub user_id: i64,
1667}
1668
1669#[derive(Debug, Clone, Serialize)]
1670pub struct GenerateVolumeSttKeyRequest {
1671    #[serde(rename = "userId", skip_serializing_if = "Option::is_none")]
1672    pub user_id: Option<i64>,
1673    #[serde(rename = "expirySeconds")]
1674    pub expiry_seconds: i64,
1675}
1676
1677#[derive(Debug, Clone, Serialize, Deserialize)]
1678pub struct GenerateSttKeyVolumeResponse {
1679    #[serde(rename = "apiKey")]
1680    pub api_key: String,
1681    #[serde(rename = "apiSecret")]
1682    pub api_secret: String,
1683    #[serde(rename = "expiresAt")]
1684    pub expires_at: String,
1685}
1686
1687#[derive(Debug, Clone, Serialize)]
1688pub struct UpdateVolumeQuotaRequest {
1689    #[serde(rename = "quotaLimit")]
1690    pub quota_limit: i64,
1691}
1692
1693#[derive(Debug, Clone, Serialize)]
1694pub struct UpdateVolumeCopysetConfigRequest {
1695    #[serde(rename = "targetCopysetCount")]
1696    pub target_copyset_count: i32,
1697}
1698
1699#[derive(Debug, Clone, Serialize, Deserialize)]
1700pub struct StatsVolumeResponse {
1701    #[serde(rename = "volumeId")]
1702    pub volume_id: String,
1703    #[serde(rename = "liveVolume")]
1704    pub live_volume: i64,
1705    #[serde(rename = "totalVolume")]
1706    pub total_volume: i64,
1707    #[serde(rename = "pendingVolume")]
1708    pub pending_volume: i64,
1709    #[serde(rename = "liveInactiveVolume")]
1710    pub live_inactive_volume: i64,
1711}
1712
1713#[derive(Debug, Clone, Serialize, Deserialize)]
1714pub struct SizeHistoryVolumeResponse {
1715    pub points: Vec<VolumeSizePoint>,
1716}
1717
1718#[derive(Debug, Clone, Serialize)]
1719pub struct CreateVolumeForkRequest {
1720    pub name: String,
1721    #[serde(rename = "parentName", skip_serializing_if = "Option::is_none")]
1722    pub parent_name: Option<String>,
1723    #[serde(rename = "asOf", skip_serializing_if = "Option::is_none")]
1724    pub as_of: Option<i64>,
1725    #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1726    pub volume_type: Option<String>,
1727}
1728
1729#[derive(Debug, Clone, Serialize)]
1730pub struct DeleteVolumeForkRequest {
1731    #[serde(skip_serializing_if = "Option::is_none")]
1732    pub force: Option<bool>,
1733    #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1734    pub volume_type: Option<String>,
1735}
1736
1737#[derive(Debug, Clone, Serialize, Deserialize)]
1738pub struct DeleteForkVolumeResponse {
1739    #[serde(rename = "inactivatedFids")]
1740    pub inactivated_fids: Vec<i32>,
1741}
1742
1743#[derive(Debug, Clone, Serialize)]
1744pub struct RestoreVolumeForkRequest {
1745    #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1746    pub volume_type: Option<String>,
1747}
1748
1749#[derive(Debug, Clone, Default)]
1750pub struct VolumeListOptions {
1751    pub account_id: i64,
1752    pub region_id: Option<i64>,
1753    pub metadata_cluster_id: Option<i64>,
1754    pub storage_id: Option<i64>,
1755    pub volume_type: Option<String>,
1756    pub locked: Option<bool>,
1757    pub is_active: Option<bool>,
1758    pub page: Option<i64>,
1759    pub limit: Option<i64>,
1760}
1761
1762// VolumeForkTrees
1763
1764#[derive(Debug, Clone, Default)]
1765pub struct VolumeForkTreeListOptions {
1766    pub path: Option<String>,
1767    pub as_of: Option<i64>,
1768    pub cursor: Option<i64>,
1769    pub limit: Option<i64>,
1770    pub sort: Option<String>,
1771    pub kind: Option<String>,
1772}
1773
1774// VolumeForkEntries
1775
1776#[derive(Debug, Clone, Default)]
1777pub struct VolumeForkEntryListOptions {
1778    pub path: Option<String>,
1779    pub cursor: Option<i64>,
1780    pub limit: Option<i64>,
1781}
1782
1783// VolumeForkSearches
1784
1785#[derive(Debug, Clone, Default)]
1786pub struct VolumeForkSearchListOptions {
1787    pub q: Option<String>,
1788    pub path: Option<String>,
1789    pub as_of: Option<i64>,
1790    pub exact: Option<bool>,
1791    pub cursor: Option<i64>,
1792    pub limit: Option<i64>,
1793    pub kind: Option<String>,
1794}
1795
1796// AuditLogs
1797
1798#[derive(Debug, Clone, Default)]
1799pub struct AuditLogListOptions {
1800    pub account_id: i64,
1801    pub region_id: Option<i64>,
1802    pub metadata_cluster_id: Option<i64>,
1803    pub cursor: Option<i64>,
1804    pub limit: Option<i64>,
1805    pub subject: Option<String>,
1806    pub created_by: Option<String>,
1807}
1808
1809// RegionAuditLogs
1810
1811#[derive(Debug, Clone, Default)]
1812pub struct RegionAuditLogListOptions {
1813    pub metadata_cluster_id: Option<i64>,
1814    pub cursor: Option<i64>,
1815    pub limit: Option<i64>,
1816    pub subject: Option<String>,
1817    pub node: Option<String>,
1818}
1819
1820// ServiceNodes
1821
1822#[derive(Debug, Clone, Serialize, Deserialize)]
1823pub struct StatsHistoryServiceNodeResponse {
1824    #[serde(rename = "intervalMs")]
1825    pub interval_ms: i64,
1826    pub samples: Vec<NodeStatsSample>,
1827}
1828
1829// Nodes
1830
1831// ClientSessions
1832
1833#[derive(Debug, Clone, Default)]
1834pub struct ClientSessionListOptions {
1835    pub account_id: i64,
1836    pub region_id: Option<i64>,
1837    pub metadata_cluster_id: Option<i64>,
1838    pub volume_id: Option<i64>,
1839    pub user_id: Option<i64>,
1840    pub client_type: Option<String>,
1841    pub status: Option<ClientSessionStatus>,
1842    pub is_active: Option<bool>,
1843    pub os_name: Option<String>,
1844    pub platform: Option<String>,
1845    pub search: Option<String>,
1846    pub page: Option<i64>,
1847    pub limit: Option<i64>,
1848}
1849
1850// Discover
1851
1852// Metrics
1853
1854#[derive(Debug, Clone, Serialize)]
1855pub struct GenerateMetricTokenRequest {
1856    #[serde(rename = "expirySeconds")]
1857    pub expiry_seconds: i64,
1858}
1859
1860// Dashboard
1861
1862// License
1863
1864#[derive(Debug, Clone, Serialize)]
1865pub struct LoadLicenseRequest {
1866    pub payloads: Vec<String>,
1867}
1868
1869// Alerts
1870
1871#[derive(Debug, Clone, Serialize, Deserialize)]
1872pub struct ResolveAlertResponse {
1873    #[serde(rename = "alertId")]
1874    pub alert_id: String,
1875}
1876
1877#[derive(Debug, Clone, Default)]
1878pub struct AlertListOptions {
1879    pub active: Option<bool>,
1880    pub account_id: Option<i64>,
1881    pub region_id: Option<i64>,
1882    pub severity: Option<i64>,
1883    pub category: Option<String>,
1884    pub since: Option<String>,
1885    pub page: Option<i64>,
1886    pub limit: Option<i64>,
1887}
1888
1889// RegionAlerts
1890
1891#[derive(Debug, Clone, Serialize, Deserialize)]
1892pub struct ResolveRegionAlertResponse {
1893    #[serde(rename = "alertId")]
1894    pub alert_id: String,
1895}
1896
1897#[derive(Debug, Clone, Default)]
1898pub struct RegionAlertListOptions {
1899    pub active: Option<bool>,
1900    pub severity: Option<i64>,
1901    pub category: Option<String>,
1902    pub node_id: Option<String>,
1903    pub metadata_cluster_id: Option<i64>,
1904    pub since: Option<String>,
1905    pub page: Option<i64>,
1906    pub limit: Option<i64>,
1907}
1908
1909// GCWorkerEvents
1910
1911#[derive(Debug, Clone, Default)]
1912pub struct GCWorkerEventListOptions {
1913    pub node_id: Option<String>,
1914    pub goal: Option<String>,
1915    pub sid: Option<i64>,
1916    pub metadata_cluster_id: Option<i64>,
1917    pub since: Option<String>,
1918    pub page: Option<i64>,
1919    pub limit: Option<i64>,
1920}
1921
1922// Vault
mountos_admin_sdk/types_gen.rs

mountos_admin_sdk/
types_gen.rs
