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

mountos_admin_sdk/
types_gen.rs
