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    #[serde(rename = "failureDomain", skip_serializing_if = "Option::is_none")]
511    pub failure_domain: Option<String>,
512}
513
514#[derive(Debug, Clone, Serialize, Deserialize)]
515pub struct Volume {
516    pub id: i64,
517    pub account: Ref,
518    pub storage: Ref,
519    pub region: Ref,
520    #[serde(rename = "metadataCluster", skip_serializing_if = "Option::is_none")]
521    pub metadata_cluster: Option<Ref>,
522    pub name: String,
523    #[serde(skip_serializing_if = "Option::is_none")]
524    pub description: Option<String>,
525    #[serde(rename = "volumeType")]
526    pub volume_type: String,
527    #[serde(rename = "storageType", skip_serializing_if = "Option::is_none")]
528    pub storage_type: Option<String>,
529    pub encryption: bool,
530    #[serde(rename = "quotaLimit")]
531    pub quota_limit: i64,
532    #[serde(rename = "liveVolume")]
533    pub live_volume: i64,
534    #[serde(rename = "totalVolume")]
535    pub total_volume: i64,
536    #[serde(rename = "pendingVolume")]
537    pub pending_volume: i64,
538    #[serde(rename = "liveInactiveVolume")]
539    pub live_inactive_volume: i64,
540    pub locked: bool,
541    pub retention: VolumeRetentionPolicy,
542    pub versioning: VolumeVersioningPolicy,
543    pub compaction: String,
544    #[serde(rename = "isActive")]
545    pub is_active: bool,
546    #[serde(rename = "isCleanupMetaEnabled")]
547    pub is_cleanup_meta_enabled: bool,
548    #[serde(rename = "isCleanupStorageEnabled")]
549    pub is_cleanup_storage_enabled: bool,
550    #[serde(rename = "isCleanupVaultEnabled")]
551    pub is_cleanup_vault_enabled: bool,
552    #[serde(rename = "createdAt")]
553    pub created_at: String,
554    #[serde(rename = "updatedAt")]
555    pub updated_at: String,
556}
557
558#[derive(Debug, Clone, Serialize, Deserialize)]
559pub struct VolumeBlockPlacementConfig {
560    pub id: i64,
561    #[serde(rename = "targetCopysetCount")]
562    pub target_copyset_count: i32,
563    #[serde(rename = "currentEpoch")]
564    pub current_epoch: i64,
565    #[serde(rename = "copysetIds")]
566    pub copyset_ids: Vec<String>,
567}
568
569#[derive(Debug, Clone, Serialize, Deserialize)]
570pub struct VolumeBlockPlacementResizeResult {
571    pub id: i64,
572    #[serde(rename = "targetCopysetCount")]
573    pub target_copyset_count: i32,
574    #[serde(rename = "copysetCountBefore")]
575    pub copyset_count_before: i32,
576    #[serde(rename = "copysetsAdded")]
577    pub copysets_added: i32,
578    #[serde(rename = "copysetsRemoved")]
579    pub copysets_removed: i32,
580    #[serde(rename = "copysetCountAfter")]
581    pub copyset_count_after: i32,
582    pub epoch: i64,
583    pub partial: bool,
584    #[serde(skip_serializing_if = "Option::is_none")]
585    pub reason: Option<String>,
586}
587
588#[derive(Debug, Clone, Serialize, Deserialize)]
589pub struct Fork {
590    pub fid: i32,
591    pub name: String,
592    #[serde(rename = "parentFid")]
593    pub parent_fid: i32,
594    #[serde(rename = "parentName")]
595    pub parent_name: String,
596    #[serde(rename = "snapshotTs")]
597    pub snapshot_ts: i64,
598    #[serde(rename = "createdBy", skip_serializing_if = "Option::is_none")]
599    pub created_by: Option<i64>,
600    #[serde(rename = "createdAt")]
601    pub created_at: i64,
602    #[serde(rename = "childrenCount")]
603    pub children_count: i32,
604    #[serde(skip_serializing_if = "Option::is_none")]
605    pub inactive: Option<bool>,
606    #[serde(rename = "inactiveAt", skip_serializing_if = "Option::is_none")]
607    pub inactive_at: Option<i64>,
608    pub status: String,
609    pub size: i64,
610}
611
612#[derive(Debug, Clone, Serialize, Deserialize)]
613pub struct ForkTreeEntry {
614    pub inode: i64,
615    pub name: String,
616    pub kind: String,
617    pub size: i64,
618    pub mtime: i64,
619    pub ctime: i64,
620    #[serde(rename = "creatorId", skip_serializing_if = "Option::is_none")]
621    pub creator_id: Option<i64>,
622    #[serde(rename = "updaterId", skip_serializing_if = "Option::is_none")]
623    pub updater_id: Option<i64>,
624}
625
626#[derive(Debug, Clone, Serialize, Deserialize)]
627pub struct ForkEntryDetail {
628    pub inode: i64,
629    pub path: String,
630    pub name: String,
631    pub kind: String,
632    pub size: i64,
633    pub mtime: i64,
634    pub ctime: i64,
635    pub generation: i64,
636    #[serde(skip_serializing_if = "Option::is_none")]
637    pub owner: Option<String>,
638    #[serde(skip_serializing_if = "Option::is_none")]
639    pub mode: Option<i32>,
640    #[serde(skip_serializing_if = "Option::is_none")]
641    pub xattrs: Option<serde_json::Value>,
642    #[serde(rename = "creatorId", skip_serializing_if = "Option::is_none")]
643    pub creator_id: Option<i64>,
644    #[serde(rename = "updaterId", skip_serializing_if = "Option::is_none")]
645    pub updater_id: Option<i64>,
646}
647
648#[derive(Debug, Clone, Serialize, Deserialize)]
649pub struct ForkEntryVersion {
650    pub generation: i64,
651    pub size: i64,
652    pub mtime: i64,
653    #[serde(rename = "updaterId", skip_serializing_if = "Option::is_none")]
654    pub updater_id: Option<i64>,
655    #[serde(rename = "contentHash", skip_serializing_if = "Option::is_none")]
656    pub content_hash: Option<String>,
657}
658
659#[derive(Debug, Clone, Serialize, Deserialize)]
660pub struct ForkTreeMatch {
661    pub path: String,
662    pub inode: i64,
663    pub kind: String,
664    pub size: i64,
665    pub mtime: i64,
666}
667
668#[derive(Debug, Clone, Serialize, Deserialize)]
669pub struct AuditLog {
670    pub id: i64,
671    pub title: String,
672    #[serde(skip_serializing_if = "Option::is_none")]
673    pub description: Option<String>,
674    #[serde(skip_serializing_if = "Option::is_none")]
675    pub subject: Option<String>,
676    pub success: bool,
677    #[serde(skip_serializing_if = "Option::is_none")]
678    pub data: Option<serde_json::Value>,
679    #[serde(rename = "createdBy", skip_serializing_if = "Option::is_none")]
680    pub created_by: Option<String>,
681    #[serde(skip_serializing_if = "Option::is_none")]
682    pub node: Option<String>,
683    #[serde(rename = "accountId", skip_serializing_if = "Option::is_none")]
684    pub account_id: Option<i64>,
685    #[serde(rename = "regionId", skip_serializing_if = "Option::is_none")]
686    pub region_id: Option<i64>,
687    #[serde(rename = "metadataClusterId", skip_serializing_if = "Option::is_none")]
688    pub metadata_cluster_id: Option<i64>,
689    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
690    pub created_at: Option<String>,
691    #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")]
692    pub updated_at: Option<String>,
693}
694
695#[derive(Debug, Clone, Serialize, Deserialize)]
696pub struct ServiceNode {
697    pub id: i64,
698    #[serde(rename = "regionId")]
699    pub region_id: i64,
700    #[serde(rename = "metadataClusterId", skip_serializing_if = "Option::is_none")]
701    pub metadata_cluster_id: Option<i64>,
702    #[serde(rename = "serviceType")]
703    pub service_type: String,
704    #[serde(rename = "nodeId")]
705    pub node_id: String,
706    #[serde(rename = "advertiseAddr")]
707    pub advertise_addr: String,
708    #[serde(rename = "rpcAddr", skip_serializing_if = "Option::is_none")]
709    pub rpc_addr: Option<String>,
710    #[serde(skip_serializing_if = "Option::is_none")]
711    pub metadata: Option<serde_json::Value>,
712    #[serde(rename = "metricsEndpoint", skip_serializing_if = "Option::is_none")]
713    pub metrics_endpoint: Option<String>,
714    #[serde(rename = "instanceId", skip_serializing_if = "Option::is_none")]
715    pub instance_id: Option<String>,
716    #[serde(rename = "instanceInfo", skip_serializing_if = "Option::is_none")]
717    pub instance_info: Option<serde_json::Value>,
718    pub status: String,
719    #[serde(rename = "lastHeartbeat", skip_serializing_if = "Option::is_none")]
720    pub last_heartbeat: Option<i64>,
721    #[serde(rename = "isActive")]
722    pub is_active: bool,
723    #[serde(rename = "memUsage", skip_serializing_if = "Option::is_none")]
724    pub mem_usage: Option<f64>,
725    #[serde(rename = "sysLoad", skip_serializing_if = "Option::is_none")]
726    pub sys_load: Option<i64>,
727    #[serde(rename = "binaryVersion", skip_serializing_if = "Option::is_none")]
728    pub binary_version: Option<i32>,
729}
730
731#[derive(Debug, Clone, Serialize, Deserialize)]
732pub struct ClientSession {
733    pub id: i64,
734    pub account: Ref,
735    pub region: Ref,
736    #[serde(rename = "metadataCluster", skip_serializing_if = "Option::is_none")]
737    pub metadata_cluster: Option<Ref>,
738    pub volume: VolumeRef,
739    #[serde(skip_serializing_if = "Option::is_none")]
740    pub user: Option<Ref>,
741    #[serde(rename = "clientType")]
742    pub client_type: String,
743    #[serde(rename = "osName")]
744    pub os_name: String,
745    #[serde(rename = "osVersion", skip_serializing_if = "Option::is_none")]
746    pub os_version: Option<String>,
747    #[serde(rename = "appVersion", skip_serializing_if = "Option::is_none")]
748    pub app_version: Option<String>,
749    #[serde(skip_serializing_if = "Option::is_none")]
750    pub hostname: Option<String>,
751    #[serde(rename = "ipAddr")]
752    pub ip_addr: String,
753    #[serde(rename = "mountMode", skip_serializing_if = "Option::is_none")]
754    pub mount_mode: Option<String>,
755    #[serde(rename = "mountPath", skip_serializing_if = "Option::is_none")]
756    pub mount_path: Option<String>,
757    #[serde(rename = "forkName", skip_serializing_if = "Option::is_none")]
758    pub fork_name: Option<String>,
759    #[serde(rename = "isTemporaryFork")]
760    pub is_temporary_fork: bool,
761    #[serde(skip_serializing_if = "Option::is_none")]
762    pub metadata: Option<serde_json::Value>,
763    #[serde(skip_serializing_if = "Option::is_none")]
764    pub metrics: Option<serde_json::Value>,
765    pub status: ClientSessionStatus,
766    #[serde(rename = "lastHeartbeat", skip_serializing_if = "Option::is_none")]
767    pub last_heartbeat: Option<i64>,
768    #[serde(rename = "connectedAt", skip_serializing_if = "Option::is_none")]
769    pub connected_at: Option<i64>,
770    #[serde(rename = "disconnectedAt", skip_serializing_if = "Option::is_none")]
771    pub disconnected_at: Option<i64>,
772    #[serde(rename = "isActive")]
773    pub is_active: bool,
774}
775
776#[derive(Debug, Clone, Serialize, Deserialize)]
777pub struct SessionSummary {
778    #[serde(rename = "byStatus")]
779    pub by_status: Vec<SessionSummaryStatusEntry>,
780    #[serde(rename = "byPlatform")]
781    pub by_platform: Vec<SessionSummaryFacet>,
782    #[serde(rename = "byOsName")]
783    pub by_os_name: Vec<SessionSummaryFacet>,
784    #[serde(rename = "regionCount")]
785    pub region_count: i64,
786    #[serde(rename = "volumeCount")]
787    pub volume_count: i64,
788    #[serde(rename = "hostCount")]
789    pub host_count: i64,
790    #[serde(rename = "degradedCount")]
791    pub degraded_count: i64,
792}
793
794#[derive(Debug, Clone, Serialize, Deserialize)]
795pub struct DiscoverMetaResponse {
796    #[serde(rename = "regionId")]
797    pub region_id: i64,
798    pub region: String,
799    pub endpoints: Vec<DiscoverEndpoint>,
800}
801
802#[derive(Debug, Clone, Serialize, Deserialize)]
803pub struct MetricsTarget {
804    pub targets: Vec<String>,
805    pub labels: serde_json::Value,
806}
807
808#[derive(Debug, Clone, Serialize, Deserialize)]
809pub struct MetricsTokenResponse {
810    pub token: String,
811}
812
813#[derive(Debug, Clone, Serialize, Deserialize)]
814pub struct DashboardStats {
815    #[serde(rename = "userCount")]
816    pub user_count: i64,
817    #[serde(rename = "volumeCount")]
818    pub volume_count: i64,
819    #[serde(rename = "regionCount")]
820    pub region_count: i64,
821    #[serde(rename = "storageCount")]
822    pub storage_count: i64,
823    #[serde(rename = "totalVolumeUsed")]
824    pub total_volume_used: i64,
825    #[serde(rename = "totalQuotaLimit")]
826    pub total_quota_limit: i64,
827    #[serde(rename = "activeSessionCount")]
828    pub active_session_count: i64,
829    #[serde(rename = "regionBreakdown")]
830    pub region_breakdown: Vec<RegionVolumeMetrics>,
831}
832
833#[derive(Debug, Clone, Serialize, Deserialize)]
834pub struct LicenseDetails {
835    #[serde(rename = "licenseId")]
836    pub license_id: String,
837    pub licensee: String,
838    pub contact: String,
839    #[serde(rename = "licenseType")]
840    pub license_type: String,
841    #[serde(rename = "issuedAt")]
842    pub issued_at: String,
843    #[serde(rename = "expiresAt")]
844    pub expires_at: String,
845    #[serde(rename = "gracePeriodDays")]
846    pub grace_period_days: i64,
847    #[serde(rename = "expiredAccessDays")]
848    pub expired_access_days: i64,
849    #[serde(rename = "maxNodes")]
850    pub max_nodes: i64,
851    #[serde(rename = "maxVolumes")]
852    pub max_volumes: i64,
853    #[serde(rename = "maxUsers")]
854    pub max_users: i64,
855    #[serde(rename = "maxAccounts")]
856    pub max_accounts: i64,
857    #[serde(rename = "maxRegions")]
858    pub max_regions: i64,
859    #[serde(rename = "maxStorageBytes")]
860    pub max_storage_bytes: i64,
861    pub status: LicenseStatus,
862    #[serde(rename = "daysRemaining")]
863    pub days_remaining: i64,
864    #[serde(rename = "graceEndsAt")]
865    pub grace_ends_at: String,
866    #[serde(rename = "graceDaysLeft")]
867    pub grace_days_left: i64,
868    #[serde(rename = "expiredAccessEndsAt")]
869    pub expired_access_ends_at: String,
870    #[serde(rename = "expiredAccessDaysLeft")]
871    pub expired_access_days_left: i64,
872    pub quota: LicenseQuota,
873    #[serde(skip_serializing_if = "Option::is_none")]
874    pub distribution: Option<String>,
875    #[serde(rename = "distributionRef", skip_serializing_if = "Option::is_none")]
876    pub distribution_ref: Option<Vec<String>>,
877    #[serde(rename = "unlimitedStorage", skip_serializing_if = "Option::is_none")]
878    pub unlimited_storage: Option<bool>,
879}
880
881#[derive(Debug, Clone, Serialize, Deserialize)]
882pub struct LicenseTerms {
883    pub terms: String,
884}
885
886#[derive(Debug, Clone, Serialize, Deserialize)]
887pub struct LicenseLoadResult {
888    pub loaded: i64,
889    pub ignored: i64,
890}
891
892#[derive(Debug, Clone, Serialize, Deserialize)]
893pub struct LicenseList {
894    pub items: Vec<LicenseRecord>,
895}
896
897#[derive(Debug, Clone, Serialize, Deserialize)]
898pub struct ServiceAlert {
899    pub id: i64,
900    #[serde(rename = "alertId")]
901    pub alert_id: String,
902    pub source: String,
903    #[serde(rename = "nodeId")]
904    pub node_id: String,
905    pub severity: i64,
906    pub category: String,
907    pub title: String,
908    #[serde(skip_serializing_if = "Option::is_none")]
909    pub description: Option<String>,
910    #[serde(skip_serializing_if = "Option::is_none")]
911    pub region: Option<Ref>,
912    #[serde(skip_serializing_if = "Option::is_none")]
913    pub account: Option<Ref>,
914    #[serde(rename = "eventTime")]
915    pub event_time: String,
916    #[serde(rename = "resolvedAt", skip_serializing_if = "Option::is_none")]
917    pub resolved_at: Option<String>,
918    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
919    pub created_at: Option<String>,
920}
921
922#[derive(Debug, Clone, Serialize, Deserialize)]
923pub struct AlertCountResponse {
924    pub active: i64,
925    pub recent: i64,
926    #[serde(rename = "infoCount")]
927    pub info_count: i64,
928    #[serde(rename = "warningCount")]
929    pub warning_count: i64,
930    #[serde(rename = "criticalCount")]
931    pub critical_count: i64,
932    #[serde(rename = "asOf")]
933    pub as_of: String,
934}
935
936#[derive(Debug, Clone, Serialize, Deserialize)]
937pub struct RegionAlert {
938    pub id: i64,
939    #[serde(rename = "alertId")]
940    pub alert_id: String,
941    pub source: String,
942    #[serde(rename = "nodeId")]
943    pub node_id: String,
944    #[serde(rename = "metadataClusterId", skip_serializing_if = "Option::is_none")]
945    pub metadata_cluster_id: Option<i64>,
946    pub severity: i64,
947    pub category: String,
948    pub title: String,
949    #[serde(skip_serializing_if = "Option::is_none")]
950    pub description: Option<String>,
951    #[serde(rename = "eventTime")]
952    pub event_time: String,
953    #[serde(rename = "resolvedAt", skip_serializing_if = "Option::is_none")]
954    pub resolved_at: Option<String>,
955    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
956    pub created_at: Option<String>,
957}
958
959#[derive(Debug, Clone, Serialize, Deserialize)]
960pub struct GCWorkerEvent {
961    pub id: i64,
962    #[serde(rename = "nodeId")]
963    pub node_id: String,
964    #[serde(rename = "metadataClusterId", skip_serializing_if = "Option::is_none")]
965    pub metadata_cluster_id: Option<i64>,
966    pub goal: String,
967    #[serde(skip_serializing_if = "Option::is_none")]
968    pub sid: Option<i64>,
969    #[serde(skip_serializing_if = "Option::is_none")]
970    pub subject: Option<String>,
971    pub ops: serde_json::Value,
972    #[serde(rename = "durationMs")]
973    pub duration_ms: i64,
974    #[serde(rename = "eventTime")]
975    pub event_time: String,
976    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
977    pub created_at: Option<String>,
978}
979
980#[derive(Debug, Clone, Serialize, Deserialize)]
981pub struct GCWorkerEventHistogramResponse {
982    pub buckets: Vec<GCWorkerEventBucket>,
983}
984
985#[derive(Debug, Clone, Serialize, Deserialize)]
986pub struct GCWorkerEventGoalsResponse {
987    pub goals: Vec<String>,
988}
989
990#[derive(Debug, Clone, Serialize, Deserialize)]
991pub struct BackfillFailure {
992    #[serde(rename = "shardId")]
993    pub shard_id: i64,
994    pub error: String,
995}
996
997#[derive(Debug, Clone, Serialize, Deserialize)]
998pub struct CompatibleStorage {
999    pub id: i64,
1000    pub uuid: String,
1001    pub name: String,
1002    #[serde(rename = "storageType")]
1003    pub storage_type: String,
1004    #[serde(rename = "providerType")]
1005    pub provider_type: String,
1006    pub volumes: Vec<CompatibleVolume>,
1007}
1008
1009#[derive(Debug, Clone, Serialize, Deserialize)]
1010pub struct CompatibleVolume {
1011    pub id: String,
1012    pub name: String,
1013}
1014
1015#[derive(Debug, Clone, Serialize, Deserialize)]
1016pub struct DashboardUser {
1017    pub id: String,
1018    pub name: String,
1019    #[serde(skip_serializing_if = "Option::is_none")]
1020    pub email: Option<String>,
1021    pub role: String,
1022    #[serde(skip_serializing_if = "Option::is_none")]
1023    pub username: Option<String>,
1024    #[serde(rename = "accountId", skip_serializing_if = "Option::is_none")]
1025    pub account_id: Option<i64>,
1026    #[serde(rename = "userId", skip_serializing_if = "Option::is_none")]
1027    pub user_id: Option<i64>,
1028    #[serde(rename = "volumeId", skip_serializing_if = "Option::is_none")]
1029    pub volume_id: Option<i64>,
1030    #[serde(skip_serializing_if = "Option::is_none")]
1031    pub exp: Option<i64>,
1032}
1033
1034#[derive(Debug, Clone, Serialize, Deserialize)]
1035pub struct DiscoverEndpoint {
1036    #[serde(rename = "nodeId")]
1037    pub node_id: String,
1038    pub addr: String,
1039    pub status: String,
1040}
1041
1042#[derive(Debug, Clone, Serialize, Deserialize)]
1043pub struct GCWorkerEventBucket {
1044    #[serde(rename = "bucketStart")]
1045    pub bucket_start: String,
1046    pub goal: String,
1047    pub count: i64,
1048}
1049
1050#[derive(Debug, Clone, Serialize, Deserialize)]
1051pub struct LicenseQuota {
1052    pub state: LicenseQuotaState,
1053    #[serde(rename = "liveVolume")]
1054    pub live_volume: i64,
1055    #[serde(rename = "totalVolume")]
1056    pub total_volume: i64,
1057    pub generation: i64,
1058    #[serde(rename = "lastTransitionAtMs")]
1059    pub last_transition_at_ms: i64,
1060}
1061
1062#[derive(Debug, Clone, Serialize, Deserialize)]
1063pub struct LicenseRecord {
1064    pub key: String,
1065    pub licensee: String,
1066    pub status: LicenseStatus,
1067    #[serde(rename = "issuedAt")]
1068    pub issued_at: String,
1069    #[serde(rename = "expiresAt")]
1070    pub expires_at: String,
1071    #[serde(rename = "maxStorageBytes")]
1072    pub max_storage_bytes: i64,
1073    #[serde(rename = "insertedAt")]
1074    pub inserted_at: String,
1075}
1076
1077#[derive(Debug, Clone, Serialize, Deserialize)]
1078pub struct MoveVolumeFailure {
1079    #[serde(rename = "volumeId")]
1080    pub volume_id: String,
1081    pub error: String,
1082}
1083
1084#[derive(Debug, Clone, Serialize, Deserialize)]
1085pub struct NodeStatsSample {
1086    #[serde(rename = "timestampMs")]
1087    pub timestamp_ms: i64,
1088    #[serde(rename = "intervalMs")]
1089    pub interval_ms: i64,
1090    #[serde(rename = "loadAvg1")]
1091    pub load_avg1: f64,
1092    #[serde(rename = "loadAvg5")]
1093    pub load_avg5: f64,
1094    #[serde(rename = "loadAvg15")]
1095    pub load_avg15: f64,
1096    #[serde(rename = "memUsage")]
1097    pub mem_usage: f64,
1098    #[serde(rename = "readIops")]
1099    pub read_iops: f64,
1100    #[serde(rename = "writeIops")]
1101    pub write_iops: f64,
1102    #[serde(rename = "netRxBytesPerSec")]
1103    pub net_rx_bytes_per_sec: f64,
1104    #[serde(rename = "netTxBytesPerSec")]
1105    pub net_tx_bytes_per_sec: f64,
1106    #[serde(rename = "processCount")]
1107    pub process_count: i64,
1108    #[serde(rename = "diskUsedBytes", skip_serializing_if = "Option::is_none")]
1109    pub disk_used_bytes: Option<i64>,
1110    #[serde(rename = "diskTotalBytes", skip_serializing_if = "Option::is_none")]
1111    pub disk_total_bytes: Option<i64>,
1112    #[serde(rename = "dbLatency1mUs", skip_serializing_if = "Option::is_none")]
1113    pub db_latency1m_us: Option<f64>,
1114    #[serde(rename = "dbLatency5mUs", skip_serializing_if = "Option::is_none")]
1115    pub db_latency5m_us: Option<f64>,
1116    #[serde(rename = "dbLatency15mUs", skip_serializing_if = "Option::is_none")]
1117    pub db_latency15m_us: Option<f64>,
1118    #[serde(rename = "dbQueriesPerSec", skip_serializing_if = "Option::is_none")]
1119    pub db_queries_per_sec: Option<f64>,
1120    #[serde(rename = "dbConnsInUse", skip_serializing_if = "Option::is_none")]
1121    pub db_conns_in_use: Option<i64>,
1122    #[serde(rename = "dbConnsMax", skip_serializing_if = "Option::is_none")]
1123    pub db_conns_max: Option<i64>,
1124    #[serde(rename = "dbConnsIdle", skip_serializing_if = "Option::is_none")]
1125    pub db_conns_idle: Option<i64>,
1126    #[serde(rename = "dbConnsFree", skip_serializing_if = "Option::is_none")]
1127    pub db_conns_free: Option<i64>,
1128    #[serde(rename = "dbConnsInUse1m", skip_serializing_if = "Option::is_none")]
1129    pub db_conns_in_use1m: Option<f64>,
1130    #[serde(rename = "dbConnsInUse5m", skip_serializing_if = "Option::is_none")]
1131    pub db_conns_in_use5m: Option<f64>,
1132    #[serde(rename = "dbConnsInUse15m", skip_serializing_if = "Option::is_none")]
1133    pub db_conns_in_use15m: Option<f64>,
1134    #[serde(rename = "dbPingAvgUs", skip_serializing_if = "Option::is_none")]
1135    pub db_ping_avg_us: Option<f64>,
1136    #[serde(rename = "dbPingMinUs", skip_serializing_if = "Option::is_none")]
1137    pub db_ping_min_us: Option<f64>,
1138    #[serde(rename = "dbPingMaxUs", skip_serializing_if = "Option::is_none")]
1139    pub db_ping_max_us: Option<f64>,
1140    #[serde(rename = "dbPingStdDevUs", skip_serializing_if = "Option::is_none")]
1141    pub db_ping_std_dev_us: Option<f64>,
1142    #[serde(rename = "dbDispatchOutstanding", skip_serializing_if = "Option::is_none")]
1143    pub db_dispatch_outstanding: Option<i64>,
1144    #[serde(rename = "dbDispatchLaneCap", skip_serializing_if = "Option::is_none")]
1145    pub db_dispatch_lane_cap: Option<i64>,
1146}
1147
1148#[derive(Debug, Clone, Serialize, Deserialize)]
1149pub struct Ref {
1150    pub id: i64,
1151    pub name: String,
1152}
1153
1154#[derive(Debug, Clone, Serialize, Deserialize)]
1155pub struct RegionVolumeMetrics {
1156    #[serde(rename = "regionId")]
1157    pub region_id: i64,
1158    #[serde(rename = "regionName")]
1159    pub region_name: String,
1160    #[serde(rename = "volumeCount")]
1161    pub volume_count: i64,
1162    #[serde(rename = "totalVolumeUsed")]
1163    pub total_volume_used: i64,
1164    #[serde(rename = "totalQuotaLimit")]
1165    pub total_quota_limit: i64,
1166}
1167
1168#[derive(Debug, Clone, Serialize, Deserialize)]
1169pub struct RetentionPolicy {
1170    #[serde(rename = "clientSessionDays", skip_serializing_if = "Option::is_none")]
1171    pub client_session_days: Option<i32>,
1172}
1173
1174#[derive(Debug, Clone, Serialize, Deserialize)]
1175pub struct SessionSummaryFacet {
1176    pub label: String,
1177    pub count: i64,
1178}
1179
1180#[derive(Debug, Clone, Serialize, Deserialize)]
1181pub struct SessionSummaryStatusEntry {
1182    #[serde(rename = "clientType")]
1183    pub client_type: String,
1184    pub status: String,
1185    pub count: i64,
1186}
1187
1188#[derive(Debug, Clone, Serialize, Deserialize)]
1189pub struct UserLite {
1190    pub id: i64,
1191    pub username: String,
1192    pub name: String,
1193}
1194
1195#[derive(Debug, Clone, Serialize, Deserialize)]
1196pub struct VolumeApiKey {
1197    #[serde(rename = "apiKey")]
1198    pub api_key: String,
1199    #[serde(skip_serializing_if = "Option::is_none")]
1200    pub name: Option<String>,
1201    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
1202    pub created_at: Option<String>,
1203    #[serde(rename = "lastUsedAt", skip_serializing_if = "Option::is_none")]
1204    pub last_used_at: Option<String>,
1205}
1206
1207#[derive(Debug, Clone, Serialize, Deserialize)]
1208pub struct VolumeRef {
1209    pub id: i64,
1210    pub name: String,
1211    #[serde(skip_serializing_if = "Option::is_none")]
1212    pub r#type: Option<String>,
1213}
1214
1215#[derive(Debug, Clone, Serialize, Deserialize)]
1216pub struct VolumeRetentionPolicy {
1217    #[serde(rename = "dataDays", skip_serializing_if = "Option::is_none")]
1218    pub data_days: Option<i32>,
1219    #[serde(rename = "graceDays", skip_serializing_if = "Option::is_none")]
1220    pub grace_days: Option<i32>,
1221    #[serde(rename = "forkGraceDays", skip_serializing_if = "Option::is_none")]
1222    pub fork_grace_days: Option<i32>,
1223    #[serde(rename = "eventLogDays", skip_serializing_if = "Option::is_none")]
1224    pub event_log_days: Option<i32>,
1225}
1226
1227#[derive(Debug, Clone, Serialize, Deserialize)]
1228pub struct VolumeSizePoint {
1229    #[serde(rename = "bucketEnd")]
1230    pub bucket_end: String,
1231    #[serde(rename = "liveVolume")]
1232    pub live_volume: i64,
1233    #[serde(rename = "totalVolume")]
1234    pub total_volume: i64,
1235    #[serde(rename = "pendingVolume")]
1236    pub pending_volume: i64,
1237    #[serde(rename = "liveInactiveVolume")]
1238    pub live_inactive_volume: i64,
1239}
1240
1241#[derive(Debug, Clone, Serialize, Deserialize)]
1242pub struct VolumeVersioningPolicy {
1243    #[serde(rename = "contentWindowSeconds", skip_serializing_if = "Option::is_none")]
1244    pub content_window_seconds: Option<i32>,
1245}
1246
1247// Accounts
1248
1249#[derive(Debug, Clone, Serialize)]
1250pub struct CreateAccountRequest {
1251    pub name: String,
1252    #[serde(skip_serializing_if = "Option::is_none")]
1253    pub description: Option<String>,
1254    #[serde(rename = "iconUrl", skip_serializing_if = "Option::is_none")]
1255    pub icon_url: Option<String>,
1256    #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
1257    pub provider_info: Option<serde_json::Value>,
1258}
1259
1260#[derive(Debug, Clone, Serialize)]
1261pub struct EditAccountRequest {
1262    pub name: String,
1263    #[serde(skip_serializing_if = "Option::is_none")]
1264    pub description: Option<String>,
1265    #[serde(rename = "iconUrl", skip_serializing_if = "Option::is_none")]
1266    pub icon_url: Option<String>,
1267    #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
1268    pub provider_info: Option<serde_json::Value>,
1269    #[serde(skip_serializing_if = "Option::is_none")]
1270    pub retention: Option<RetentionPolicy>,
1271}
1272
1273#[derive(Debug, Clone, Serialize)]
1274pub struct UpdateAccountQuotaRequest {
1275    #[serde(rename = "quotaLimit")]
1276    pub quota_limit: i64,
1277    #[serde(rename = "quotaExcessPct", skip_serializing_if = "Option::is_none")]
1278    pub quota_excess_pct: Option<i32>,
1279}
1280
1281#[derive(Debug, Clone, Default)]
1282pub struct AccountListOptions {
1283    pub is_active: Option<bool>,
1284    pub page: Option<i64>,
1285    pub limit: Option<i64>,
1286}
1287
1288// Users
1289
1290#[derive(Debug, Clone, Serialize)]
1291pub struct AddUserRequest {
1292    #[serde(rename = "accountId")]
1293    pub account_id: i64,
1294    pub username: String,
1295    pub email: String,
1296    #[serde(skip_serializing_if = "Option::is_none")]
1297    pub name: Option<String>,
1298    #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
1299    pub provider_info: Option<serde_json::Value>,
1300}
1301
1302#[derive(Debug, Clone, Serialize)]
1303pub struct BulkUserRequest {
1304    pub ids: Vec<i64>,
1305}
1306
1307#[derive(Debug, Clone, Serialize, Deserialize)]
1308pub struct BulkUserResponse {
1309    pub users: Vec<UserLite>,
1310}
1311
1312#[derive(Debug, Clone, Serialize)]
1313pub struct EditUserRequest {
1314    pub username: String,
1315    pub email: String,
1316    #[serde(skip_serializing_if = "Option::is_none")]
1317    pub name: Option<String>,
1318    #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
1319    pub provider_info: Option<serde_json::Value>,
1320}
1321
1322#[derive(Debug, Clone, Default)]
1323pub struct UserListOptions {
1324    pub account_id: i64,
1325    pub search: Option<String>,
1326    pub is_active: Option<bool>,
1327    pub page: Option<i64>,
1328    pub limit: Option<i64>,
1329}
1330
1331// Regions
1332
1333#[derive(Debug, Clone, Serialize)]
1334pub struct CreateRegionRequest {
1335    #[serde(rename = "accountId")]
1336    pub account_id: i64,
1337    pub name: String,
1338}
1339
1340#[derive(Debug, Clone, Serialize)]
1341pub struct EditRegionRequest {
1342    #[serde(rename = "accountId")]
1343    pub account_id: i64,
1344    pub name: String,
1345}
1346
1347#[derive(Debug, Clone, Default)]
1348pub struct RegionListOptions {
1349    pub account_id: i64,
1350    pub is_active: Option<bool>,
1351    pub page: Option<i64>,
1352    pub limit: Option<i64>,
1353}
1354
1355// Clusters
1356
1357#[derive(Debug, Clone, Default)]
1358pub struct ClusterListOptions {
1359    pub account_id: i64,
1360    pub region_id: Option<i64>,
1361    pub is_active: Option<bool>,
1362    pub page: Option<i64>,
1363    pub limit: Option<i64>,
1364}
1365
1366// MetadataClusters
1367
1368#[derive(Debug, Clone, Serialize)]
1369pub struct CreateMetadataClusterRequest {
1370    pub name: String,
1371}
1372
1373#[derive(Debug, Clone, Serialize)]
1374pub struct EditMetadataClusterRequest {
1375    pub name: String,
1376}
1377
1378#[derive(Debug, Clone, Serialize)]
1379pub struct SetMetadataClusterReadyRequest {
1380    pub ready: bool,
1381}
1382
1383#[derive(Debug, Clone, Serialize, Deserialize)]
1384pub struct SetReadyMetadataClusterResponse {
1385    pub id: i64,
1386    pub ready: bool,
1387}
1388
1389#[derive(Debug, Clone, Default)]
1390pub struct MetadataClusterListOptions {
1391    pub is_active: Option<bool>,
1392    pub page: Option<i64>,
1393    pub limit: Option<i64>,
1394}
1395
1396// Storages
1397
1398#[derive(Debug, Clone, Serialize)]
1399pub struct CreateStorageRequest {
1400    #[serde(rename = "accountId")]
1401    pub account_id: i64,
1402    #[serde(rename = "regionId")]
1403    pub region_id: i64,
1404    pub name: String,
1405    #[serde(skip_serializing_if = "Option::is_none")]
1406    pub description: Option<String>,
1407    #[serde(rename = "storageType")]
1408    pub storage_type: String,
1409    #[serde(rename = "providerType")]
1410    pub provider_type: String,
1411    pub endpoint: String,
1412    #[serde(skip_serializing_if = "Option::is_none")]
1413    pub region: Option<String>,
1414    #[serde(skip_serializing_if = "Option::is_none")]
1415    pub bucket: Option<String>,
1416    #[serde(skip_serializing_if = "Option::is_none")]
1417    pub base: Option<String>,
1418    #[serde(rename = "blockRegion", skip_serializing_if = "Option::is_none")]
1419    pub block_region: Option<String>,
1420    #[serde(rename = "blockSize", skip_serializing_if = "Option::is_none")]
1421    pub block_size: Option<i32>,
1422    #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none")]
1423    pub access_key: Option<String>,
1424    #[serde(rename = "secretKey", skip_serializing_if = "Option::is_none")]
1425    pub secret_key: Option<String>,
1426}
1427
1428#[derive(Debug, Clone, Serialize)]
1429pub struct EditStorageRequest {
1430    pub name: String,
1431    #[serde(skip_serializing_if = "Option::is_none")]
1432    pub description: Option<String>,
1433    #[serde(skip_serializing_if = "Option::is_none")]
1434    pub endpoint: Option<String>,
1435    #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none")]
1436    pub access_key: Option<String>,
1437    #[serde(rename = "secretKey", skip_serializing_if = "Option::is_none")]
1438    pub secret_key: Option<String>,
1439    #[serde(rename = "directAccess", skip_serializing_if = "Option::is_none")]
1440    pub direct_access: Option<bool>,
1441}
1442
1443#[derive(Debug, Clone, Serialize)]
1444pub struct TestStorageNewBucketRequest {
1445    pub endpoint: String,
1446    #[serde(skip_serializing_if = "Option::is_none")]
1447    pub region: Option<String>,
1448    pub bucket: String,
1449    #[serde(rename = "accessKey")]
1450    pub access_key: String,
1451    #[serde(rename = "secretKey")]
1452    pub secret_key: String,
1453    #[serde(rename = "providerType", skip_serializing_if = "Option::is_none")]
1454    pub provider_type: Option<String>,
1455}
1456
1457#[derive(Debug, Clone, Serialize, Deserialize)]
1458pub struct TestNewBucketStorageResponse {
1459    #[serde(rename = "bucketExists")]
1460    pub bucket_exists: bool,
1461    pub list: bool,
1462    pub write: bool,
1463    pub read: bool,
1464    pub delete: bool,
1465    pub multipart: bool,
1466}
1467
1468#[derive(Debug, Clone, Serialize, Deserialize)]
1469pub struct TestStorageBucketStorageResponse {
1470    #[serde(rename = "bucketExists")]
1471    pub bucket_exists: bool,
1472    pub list: bool,
1473    pub write: bool,
1474    pub read: bool,
1475    pub delete: bool,
1476    pub multipart: bool,
1477}
1478
1479#[derive(Debug, Clone, Serialize, Deserialize)]
1480pub struct ListCompatibleStorageResponse {
1481    pub storages: Vec<CompatibleStorage>,
1482}
1483
1484#[derive(Debug, Clone, Serialize)]
1485pub struct MoveStorageVolumesRequest {
1486    #[serde(rename = "volumeIds")]
1487    pub volume_ids: Vec<String>,
1488}
1489
1490#[derive(Debug, Clone, Serialize, Deserialize)]
1491pub struct MoveVolumesStorageResponse {
1492    pub moved: Vec<String>,
1493    pub failures: Vec<MoveVolumeFailure>,
1494}
1495
1496#[derive(Debug, Clone, Serialize)]
1497pub struct DrainStorageCopysetRequest {
1498    #[serde(skip_serializing_if = "Option::is_none")]
1499    pub force: Option<bool>,
1500}
1501
1502#[derive(Debug, Clone, Serialize, Deserialize)]
1503pub struct DrainCopysetStorageResponse {
1504    pub id: String,
1505    pub state: String,
1506}
1507
1508#[derive(Debug, Clone, Serialize)]
1509pub struct CancelStorageDrainRequest {
1510    #[serde(skip_serializing_if = "Option::is_none")]
1511    pub force: Option<bool>,
1512}
1513
1514#[derive(Debug, Clone, Serialize, Deserialize)]
1515pub struct CancelDrainStorageResponse {
1516    pub id: String,
1517    pub state: String,
1518}
1519
1520#[derive(Debug, Clone, Serialize)]
1521pub struct UpdateStorageTagsRequest {
1522    #[serde(skip_serializing_if = "Option::is_none")]
1523    pub tags: Option<Vec<String>>,
1524}
1525
1526#[derive(Debug, Clone, Serialize)]
1527pub struct RegisterStorageCopysetRequest {
1528    #[serde(skip_serializing_if = "Option::is_none")]
1529    pub name: Option<String>,
1530    #[serde(rename = "failureDomainA", skip_serializing_if = "Option::is_none")]
1531    pub failure_domain_a: Option<String>,
1532    #[serde(rename = "failureDomainB", skip_serializing_if = "Option::is_none")]
1533    pub failure_domain_b: Option<String>,
1534}
1535
1536#[derive(Debug, Clone, Serialize)]
1537pub struct RegisterStorageCopysetsBulkRequest {
1538    pub count: i32,
1539    #[serde(rename = "failureDomainA", skip_serializing_if = "Option::is_none")]
1540    pub failure_domain_a: Option<String>,
1541    #[serde(rename = "failureDomainB", skip_serializing_if = "Option::is_none")]
1542    pub failure_domain_b: Option<String>,
1543}
1544
1545#[derive(Debug, Clone, Serialize, Deserialize)]
1546pub struct RegisterCopysetsBulkStorageResponse {
1547    pub copysets: Vec<Copyset>,
1548}
1549
1550#[derive(Debug, Clone, Serialize)]
1551pub struct AddStorageCopysetMemberRequest {
1552    #[serde(rename = "failureDomain", skip_serializing_if = "Option::is_none")]
1553    pub failure_domain: Option<String>,
1554}
1555
1556#[derive(Debug, Clone, Serialize)]
1557pub struct MarkStorageMemberLostRequest {
1558    #[serde(rename = "blockVolumeId")]
1559    pub block_volume_id: String,
1560    #[serde(skip_serializing_if = "Option::is_none")]
1561    pub force: Option<bool>,
1562}
1563
1564#[derive(Debug, Clone, Serialize, Deserialize)]
1565pub struct RemoveMemberStorageResponse {
1566    pub id: String,
1567}
1568
1569#[derive(Debug, Clone, Serialize, Deserialize)]
1570pub struct BackfillFingerprintsStorageResponse {
1571    pub scanned: i32,
1572    pub updated: i32,
1573    pub failures: Vec<BackfillFailure>,
1574    #[serde(rename = "hasMore")]
1575    pub has_more: bool,
1576}
1577
1578#[derive(Debug, Clone, Default)]
1579pub struct StorageListOptions {
1580    pub account_id: i64,
1581    pub search: Option<String>,
1582    pub region_id: Option<i64>,
1583    pub storage_type: Option<String>,
1584    pub provider_type: Option<String>,
1585    pub is_active: Option<bool>,
1586    pub direct_access: Option<bool>,
1587    pub page: Option<i64>,
1588    pub limit: Option<i64>,
1589}
1590
1591// Volumes
1592
1593#[derive(Debug, Clone, Serialize)]
1594pub struct CreateVolumeRequest {
1595    #[serde(rename = "accountId")]
1596    pub account_id: i64,
1597    #[serde(rename = "storageId")]
1598    pub storage_id: i64,
1599    pub name: String,
1600    #[serde(skip_serializing_if = "Option::is_none")]
1601    pub description: Option<String>,
1602    #[serde(rename = "volumeType")]
1603    pub volume_type: String,
1604    #[serde(skip_serializing_if = "Option::is_none")]
1605    pub encryption: Option<bool>,
1606    #[serde(rename = "encryptionKey", skip_serializing_if = "Option::is_none")]
1607    pub encryption_key: Option<String>,
1608    #[serde(skip_serializing_if = "Option::is_none")]
1609    pub retention: Option<VolumeRetentionPolicy>,
1610    #[serde(skip_serializing_if = "Option::is_none")]
1611    pub versioning: Option<VolumeVersioningPolicy>,
1612    #[serde(skip_serializing_if = "Option::is_none")]
1613    pub compaction: Option<String>,
1614    #[serde(rename = "quotaLimit", skip_serializing_if = "Option::is_none")]
1615    pub quota_limit: Option<i64>,
1616    #[serde(rename = "metadataClusterId", skip_serializing_if = "Option::is_none")]
1617    pub metadata_cluster_id: Option<i64>,
1618    #[serde(rename = "metadataClusterUuid", skip_serializing_if = "Option::is_none")]
1619    pub metadata_cluster_uuid: Option<String>,
1620}
1621
1622#[derive(Debug, Clone, Serialize, Deserialize)]
1623pub struct CreateVolumeResponse {
1624    pub id: i64,
1625    #[serde(rename = "encryptionKey", skip_serializing_if = "Option::is_none")]
1626    pub encryption_key: Option<String>,
1627}
1628
1629#[derive(Debug, Clone, Serialize)]
1630pub struct EditVolumeRequest {
1631    #[serde(skip_serializing_if = "Option::is_none")]
1632    pub description: Option<String>,
1633    #[serde(skip_serializing_if = "Option::is_none")]
1634    pub retention: Option<VolumeRetentionPolicy>,
1635    #[serde(skip_serializing_if = "Option::is_none")]
1636    pub versioning: Option<VolumeVersioningPolicy>,
1637    #[serde(skip_serializing_if = "Option::is_none")]
1638    pub compaction: Option<String>,
1639}
1640
1641#[derive(Debug, Clone, Serialize)]
1642pub struct MoveVolumeClusterRequest {
1643    #[serde(rename = "targetClusterId", skip_serializing_if = "Option::is_none")]
1644    pub target_cluster_id: Option<i64>,
1645    #[serde(rename = "targetClusterUuid", skip_serializing_if = "Option::is_none")]
1646    pub target_cluster_uuid: Option<String>,
1647}
1648
1649#[derive(Debug, Clone, Serialize, Deserialize)]
1650pub struct MoveClusterVolumeResponse {
1651    pub id: i64,
1652    #[serde(rename = "sourceClusterId")]
1653    pub source_cluster_id: i64,
1654    #[serde(rename = "targetClusterId")]
1655    pub target_cluster_id: i64,
1656    #[serde(rename = "handoverUntil")]
1657    pub handover_until: i64,
1658}
1659
1660#[derive(Debug, Clone, Serialize)]
1661pub struct DeactivateVolumeRequest {
1662    #[serde(rename = "isCleanupMetaEnabled", skip_serializing_if = "Option::is_none")]
1663    pub is_cleanup_meta_enabled: Option<bool>,
1664    #[serde(rename = "isCleanupStorageEnabled", skip_serializing_if = "Option::is_none")]
1665    pub is_cleanup_storage_enabled: Option<bool>,
1666    #[serde(rename = "isCleanupVaultEnabled", skip_serializing_if = "Option::is_none")]
1667    pub is_cleanup_vault_enabled: Option<bool>,
1668}
1669
1670#[derive(Debug, Clone, Serialize)]
1671pub struct GenerateVolumeAPIKeysRequest {
1672    #[serde(rename = "userId")]
1673    pub user_id: i64,
1674    #[serde(skip_serializing_if = "Option::is_none")]
1675    pub name: Option<String>,
1676}
1677
1678#[derive(Debug, Clone, Serialize, Deserialize)]
1679pub struct GenerateAPIKeysVolumeResponse {
1680    #[serde(rename = "apiKey")]
1681    pub api_key: String,
1682    #[serde(rename = "apiSecret")]
1683    pub api_secret: String,
1684    #[serde(rename = "evictedApiKeys", skip_serializing_if = "Option::is_none")]
1685    pub evicted_api_keys: Option<Vec<String>>,
1686}
1687
1688#[derive(Debug, Clone, Serialize, Deserialize)]
1689pub struct ListAPIKeysVolumeResponse {
1690    pub keys: Vec<VolumeApiKey>,
1691}
1692
1693#[derive(Debug, Clone, Serialize)]
1694pub struct RevokeVolumeAPIKeyRequest {
1695    #[serde(rename = "apiKey")]
1696    pub api_key: String,
1697}
1698
1699#[derive(Debug, Clone, Serialize)]
1700pub struct RevokeVolumeAPIKeysByUserRequest {
1701    #[serde(rename = "userId")]
1702    pub user_id: i64,
1703}
1704
1705#[derive(Debug, Clone, Serialize)]
1706pub struct GenerateVolumeSttKeyRequest {
1707    #[serde(rename = "userId", skip_serializing_if = "Option::is_none")]
1708    pub user_id: Option<i64>,
1709    #[serde(rename = "expirySeconds")]
1710    pub expiry_seconds: i64,
1711}
1712
1713#[derive(Debug, Clone, Serialize, Deserialize)]
1714pub struct GenerateSttKeyVolumeResponse {
1715    #[serde(rename = "apiKey")]
1716    pub api_key: String,
1717    #[serde(rename = "apiSecret")]
1718    pub api_secret: String,
1719    #[serde(rename = "expiresAt")]
1720    pub expires_at: String,
1721}
1722
1723#[derive(Debug, Clone, Serialize)]
1724pub struct UpdateVolumeQuotaRequest {
1725    #[serde(rename = "quotaLimit")]
1726    pub quota_limit: i64,
1727}
1728
1729#[derive(Debug, Clone, Serialize)]
1730pub struct UpdateVolumeCopysetConfigRequest {
1731    #[serde(rename = "targetCopysetCount")]
1732    pub target_copyset_count: i32,
1733}
1734
1735#[derive(Debug, Clone, Serialize, Deserialize)]
1736pub struct StatsVolumeResponse {
1737    #[serde(rename = "volumeId")]
1738    pub volume_id: String,
1739    #[serde(rename = "liveVolume")]
1740    pub live_volume: i64,
1741    #[serde(rename = "totalVolume")]
1742    pub total_volume: i64,
1743    #[serde(rename = "pendingVolume")]
1744    pub pending_volume: i64,
1745    #[serde(rename = "liveInactiveVolume")]
1746    pub live_inactive_volume: i64,
1747}
1748
1749#[derive(Debug, Clone, Serialize, Deserialize)]
1750pub struct SizeHistoryVolumeResponse {
1751    pub points: Vec<VolumeSizePoint>,
1752}
1753
1754#[derive(Debug, Clone, Serialize)]
1755pub struct CreateVolumeForkRequest {
1756    pub name: String,
1757    #[serde(rename = "parentName", skip_serializing_if = "Option::is_none")]
1758    pub parent_name: Option<String>,
1759    #[serde(rename = "asOf", skip_serializing_if = "Option::is_none")]
1760    pub as_of: Option<i64>,
1761    #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1762    pub volume_type: Option<String>,
1763}
1764
1765#[derive(Debug, Clone, Serialize)]
1766pub struct DeleteVolumeForkRequest {
1767    #[serde(skip_serializing_if = "Option::is_none")]
1768    pub force: Option<bool>,
1769    #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1770    pub volume_type: Option<String>,
1771}
1772
1773#[derive(Debug, Clone, Serialize, Deserialize)]
1774pub struct DeleteForkVolumeResponse {
1775    #[serde(rename = "inactivatedFids")]
1776    pub inactivated_fids: Vec<i32>,
1777}
1778
1779#[derive(Debug, Clone, Serialize)]
1780pub struct RestoreVolumeForkRequest {
1781    #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1782    pub volume_type: Option<String>,
1783}
1784
1785#[derive(Debug, Clone, Default)]
1786pub struct VolumeListOptions {
1787    pub account_id: i64,
1788    pub region_id: Option<i64>,
1789    pub metadata_cluster_id: Option<i64>,
1790    pub storage_id: Option<i64>,
1791    pub volume_type: Option<String>,
1792    pub locked: Option<bool>,
1793    pub is_active: Option<bool>,
1794    pub page: Option<i64>,
1795    pub limit: Option<i64>,
1796}
1797
1798// VolumeForkTrees
1799
1800#[derive(Debug, Clone, Default)]
1801pub struct VolumeForkTreeListOptions {
1802    pub path: Option<String>,
1803    pub as_of: Option<i64>,
1804    pub cursor: Option<i64>,
1805    pub limit: Option<i64>,
1806    pub sort: Option<String>,
1807    pub kind: Option<String>,
1808}
1809
1810// VolumeForkEntries
1811
1812#[derive(Debug, Clone, Default)]
1813pub struct VolumeForkEntryListOptions {
1814    pub path: Option<String>,
1815    pub cursor: Option<i64>,
1816    pub limit: Option<i64>,
1817}
1818
1819// VolumeForkSearches
1820
1821#[derive(Debug, Clone, Default)]
1822pub struct VolumeForkSearchListOptions {
1823    pub q: Option<String>,
1824    pub path: Option<String>,
1825    pub as_of: Option<i64>,
1826    pub exact: Option<bool>,
1827    pub cursor: Option<i64>,
1828    pub limit: Option<i64>,
1829    pub kind: Option<String>,
1830}
1831
1832// AuditLogs
1833
1834#[derive(Debug, Clone, Default)]
1835pub struct AuditLogListOptions {
1836    pub account_id: i64,
1837    pub region_id: Option<i64>,
1838    pub metadata_cluster_id: Option<i64>,
1839    pub cursor: Option<i64>,
1840    pub limit: Option<i64>,
1841    pub subject: Option<String>,
1842    pub created_by: Option<String>,
1843}
1844
1845// RegionAuditLogs
1846
1847#[derive(Debug, Clone, Default)]
1848pub struct RegionAuditLogListOptions {
1849    pub metadata_cluster_id: Option<i64>,
1850    pub cursor: Option<i64>,
1851    pub limit: Option<i64>,
1852    pub subject: Option<String>,
1853    pub node: Option<String>,
1854}
1855
1856// ServiceNodes
1857
1858#[derive(Debug, Clone, Serialize, Deserialize)]
1859pub struct StatsHistoryServiceNodeResponse {
1860    #[serde(rename = "intervalMs")]
1861    pub interval_ms: i64,
1862    pub samples: Vec<NodeStatsSample>,
1863}
1864
1865// Nodes
1866
1867// ClientSessions
1868
1869#[derive(Debug, Clone, Default)]
1870pub struct ClientSessionListOptions {
1871    pub account_id: i64,
1872    pub region_id: Option<i64>,
1873    pub metadata_cluster_id: Option<i64>,
1874    pub volume_id: Option<i64>,
1875    pub user_id: Option<i64>,
1876    pub client_type: Option<String>,
1877    pub status: Option<ClientSessionStatus>,
1878    pub is_active: Option<bool>,
1879    pub os_name: Option<String>,
1880    pub platform: Option<String>,
1881    pub search: Option<String>,
1882    pub page: Option<i64>,
1883    pub limit: Option<i64>,
1884}
1885
1886// Discover
1887
1888// Metrics
1889
1890#[derive(Debug, Clone, Serialize)]
1891pub struct GenerateMetricTokenRequest {
1892    #[serde(rename = "expirySeconds")]
1893    pub expiry_seconds: i64,
1894}
1895
1896// Dashboard
1897
1898// License
1899
1900#[derive(Debug, Clone, Serialize)]
1901pub struct LoadLicenseRequest {
1902    pub payloads: Vec<String>,
1903}
1904
1905// Alerts
1906
1907#[derive(Debug, Clone, Serialize, Deserialize)]
1908pub struct ResolveAlertResponse {
1909    #[serde(rename = "alertId")]
1910    pub alert_id: String,
1911}
1912
1913#[derive(Debug, Clone, Default)]
1914pub struct AlertListOptions {
1915    pub active: Option<bool>,
1916    pub account_id: Option<i64>,
1917    pub region_id: Option<i64>,
1918    pub severity: Option<i64>,
1919    pub category: Option<String>,
1920    pub since: Option<String>,
1921    pub page: Option<i64>,
1922    pub limit: Option<i64>,
1923}
1924
1925// RegionAlerts
1926
1927#[derive(Debug, Clone, Serialize, Deserialize)]
1928pub struct ResolveRegionAlertResponse {
1929    #[serde(rename = "alertId")]
1930    pub alert_id: String,
1931}
1932
1933#[derive(Debug, Clone, Default)]
1934pub struct RegionAlertListOptions {
1935    pub active: Option<bool>,
1936    pub severity: Option<i64>,
1937    pub category: Option<String>,
1938    pub node_id: Option<String>,
1939    pub metadata_cluster_id: Option<i64>,
1940    pub since: Option<String>,
1941    pub page: Option<i64>,
1942    pub limit: Option<i64>,
1943}
1944
1945// GCWorkerEvents
1946
1947#[derive(Debug, Clone, Default)]
1948pub struct GCWorkerEventListOptions {
1949    pub node_id: Option<String>,
1950    pub goal: Option<String>,
1951    pub sid: Option<i64>,
1952    pub metadata_cluster_id: Option<i64>,
1953    pub since: Option<String>,
1954    pub page: Option<i64>,
1955    pub limit: Option<i64>,
1956}
1957
1958// Vault
mountos_admin_sdk/types_gen.rs

mountos_admin_sdk/
types_gen.rs
