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 status: String,
1049    #[serde(skip_serializing_if = "Option::is_none")]
1050    pub public: Option<Vec<DiscoverEndpointAddr>>,
1051    #[serde(skip_serializing_if = "Option::is_none")]
1052    pub private: Option<Vec<DiscoverEndpointAddr>>,
1053}
1054
1055#[derive(Debug, Clone, Serialize, Deserialize)]
1056pub struct DiscoverEndpointAddr {
1057    pub tcp: String,
1058    #[serde(skip_serializing_if = "Option::is_none")]
1059    pub udp: Option<String>,
1060    pub family: i64,
1061}
1062
1063#[derive(Debug, Clone, Serialize, Deserialize)]
1064pub struct GCWorkerEventBucket {
1065    #[serde(rename = "bucketStart")]
1066    pub bucket_start: String,
1067    pub goal: String,
1068    pub count: i64,
1069}
1070
1071#[derive(Debug, Clone, Serialize, Deserialize)]
1072pub struct LicenseQuota {
1073    pub state: LicenseQuotaState,
1074    #[serde(rename = "liveVolume")]
1075    pub live_volume: i64,
1076    #[serde(rename = "totalVolume")]
1077    pub total_volume: i64,
1078    pub generation: i64,
1079    #[serde(rename = "lastTransitionAtMs")]
1080    pub last_transition_at_ms: i64,
1081}
1082
1083#[derive(Debug, Clone, Serialize, Deserialize)]
1084pub struct LicenseRecord {
1085    pub key: String,
1086    pub licensee: String,
1087    pub status: LicenseStatus,
1088    #[serde(rename = "issuedAt")]
1089    pub issued_at: String,
1090    #[serde(rename = "expiresAt")]
1091    pub expires_at: String,
1092    #[serde(rename = "maxStorageBytes")]
1093    pub max_storage_bytes: i64,
1094    #[serde(rename = "insertedAt")]
1095    pub inserted_at: String,
1096}
1097
1098#[derive(Debug, Clone, Serialize, Deserialize)]
1099pub struct MoveVolumeFailure {
1100    #[serde(rename = "volumeId")]
1101    pub volume_id: String,
1102    pub error: String,
1103}
1104
1105#[derive(Debug, Clone, Serialize, Deserialize)]
1106pub struct NodeAddress {
1107    pub family: i64,
1108    pub scope: String,
1109    pub advertise: String,
1110    #[serde(skip_serializing_if = "Option::is_none")]
1111    pub rpc: Option<String>,
1112}
1113
1114#[derive(Debug, Clone, Serialize, Deserialize)]
1115pub struct NodeStatsSample {
1116    #[serde(rename = "timestampMs")]
1117    pub timestamp_ms: i64,
1118    #[serde(rename = "intervalMs")]
1119    pub interval_ms: i64,
1120    #[serde(rename = "loadAvg1")]
1121    pub load_avg1: f64,
1122    #[serde(rename = "loadAvg5")]
1123    pub load_avg5: f64,
1124    #[serde(rename = "loadAvg15")]
1125    pub load_avg15: f64,
1126    #[serde(rename = "memUsage")]
1127    pub mem_usage: f64,
1128    #[serde(rename = "readIops")]
1129    pub read_iops: f64,
1130    #[serde(rename = "writeIops")]
1131    pub write_iops: f64,
1132    #[serde(rename = "netRxBytesPerSec")]
1133    pub net_rx_bytes_per_sec: f64,
1134    #[serde(rename = "netTxBytesPerSec")]
1135    pub net_tx_bytes_per_sec: f64,
1136    #[serde(rename = "processCount")]
1137    pub process_count: i64,
1138    #[serde(rename = "diskUsedBytes", skip_serializing_if = "Option::is_none")]
1139    pub disk_used_bytes: Option<i64>,
1140    #[serde(rename = "diskTotalBytes", skip_serializing_if = "Option::is_none")]
1141    pub disk_total_bytes: Option<i64>,
1142    #[serde(rename = "dbLatency1mUs", skip_serializing_if = "Option::is_none")]
1143    pub db_latency1m_us: Option<f64>,
1144    #[serde(rename = "dbLatency5mUs", skip_serializing_if = "Option::is_none")]
1145    pub db_latency5m_us: Option<f64>,
1146    #[serde(rename = "dbLatency15mUs", skip_serializing_if = "Option::is_none")]
1147    pub db_latency15m_us: Option<f64>,
1148    #[serde(rename = "dbQueriesPerSec", skip_serializing_if = "Option::is_none")]
1149    pub db_queries_per_sec: Option<f64>,
1150    #[serde(rename = "dbConnsInUse", skip_serializing_if = "Option::is_none")]
1151    pub db_conns_in_use: Option<i64>,
1152    #[serde(rename = "dbConnsMax", skip_serializing_if = "Option::is_none")]
1153    pub db_conns_max: Option<i64>,
1154    #[serde(rename = "dbConnsIdle", skip_serializing_if = "Option::is_none")]
1155    pub db_conns_idle: Option<i64>,
1156    #[serde(rename = "dbConnsFree", skip_serializing_if = "Option::is_none")]
1157    pub db_conns_free: Option<i64>,
1158    #[serde(rename = "dbConnsInUse1m", skip_serializing_if = "Option::is_none")]
1159    pub db_conns_in_use1m: Option<f64>,
1160    #[serde(rename = "dbConnsInUse5m", skip_serializing_if = "Option::is_none")]
1161    pub db_conns_in_use5m: Option<f64>,
1162    #[serde(rename = "dbConnsInUse15m", skip_serializing_if = "Option::is_none")]
1163    pub db_conns_in_use15m: Option<f64>,
1164    #[serde(rename = "dbPingAvgUs", skip_serializing_if = "Option::is_none")]
1165    pub db_ping_avg_us: Option<f64>,
1166    #[serde(rename = "dbPingMinUs", skip_serializing_if = "Option::is_none")]
1167    pub db_ping_min_us: Option<f64>,
1168    #[serde(rename = "dbPingMaxUs", skip_serializing_if = "Option::is_none")]
1169    pub db_ping_max_us: Option<f64>,
1170    #[serde(rename = "dbPingStdDevUs", skip_serializing_if = "Option::is_none")]
1171    pub db_ping_std_dev_us: Option<f64>,
1172    #[serde(rename = "dbDispatchOutstanding", skip_serializing_if = "Option::is_none")]
1173    pub db_dispatch_outstanding: Option<i64>,
1174    #[serde(rename = "dbDispatchLaneCap", skip_serializing_if = "Option::is_none")]
1175    pub db_dispatch_lane_cap: Option<i64>,
1176}
1177
1178#[derive(Debug, Clone, Serialize, Deserialize)]
1179pub struct Ref {
1180    pub id: i64,
1181    pub name: String,
1182}
1183
1184#[derive(Debug, Clone, Serialize, Deserialize)]
1185pub struct RegionVolumeMetrics {
1186    #[serde(rename = "regionId")]
1187    pub region_id: i64,
1188    #[serde(rename = "regionName")]
1189    pub region_name: String,
1190    #[serde(rename = "volumeCount")]
1191    pub volume_count: i64,
1192    #[serde(rename = "totalVolumeUsed")]
1193    pub total_volume_used: i64,
1194    #[serde(rename = "totalQuotaLimit")]
1195    pub total_quota_limit: i64,
1196}
1197
1198#[derive(Debug, Clone, Serialize, Deserialize)]
1199pub struct RetentionPolicy {
1200    #[serde(rename = "clientSessionDays", skip_serializing_if = "Option::is_none")]
1201    pub client_session_days: Option<i32>,
1202}
1203
1204#[derive(Debug, Clone, Serialize, Deserialize)]
1205pub struct SessionSummaryFacet {
1206    pub label: String,
1207    pub count: i64,
1208}
1209
1210#[derive(Debug, Clone, Serialize, Deserialize)]
1211pub struct SessionSummaryStatusEntry {
1212    #[serde(rename = "clientType")]
1213    pub client_type: String,
1214    pub status: String,
1215    pub count: i64,
1216}
1217
1218#[derive(Debug, Clone, Serialize, Deserialize)]
1219pub struct UserLite {
1220    pub id: i64,
1221    pub username: String,
1222    pub name: String,
1223}
1224
1225#[derive(Debug, Clone, Serialize, Deserialize)]
1226pub struct VolumeApiKey {
1227    #[serde(rename = "apiKey")]
1228    pub api_key: String,
1229    #[serde(skip_serializing_if = "Option::is_none")]
1230    pub name: Option<String>,
1231    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
1232    pub created_at: Option<String>,
1233    #[serde(rename = "lastUsedAt", skip_serializing_if = "Option::is_none")]
1234    pub last_used_at: Option<String>,
1235}
1236
1237#[derive(Debug, Clone, Serialize, Deserialize)]
1238pub struct VolumeRef {
1239    pub id: i64,
1240    pub name: String,
1241    #[serde(skip_serializing_if = "Option::is_none")]
1242    pub r#type: Option<String>,
1243}
1244
1245#[derive(Debug, Clone, Serialize, Deserialize)]
1246pub struct VolumeRetentionPolicy {
1247    #[serde(rename = "dataDays", skip_serializing_if = "Option::is_none")]
1248    pub data_days: Option<i32>,
1249    #[serde(rename = "graceDays", skip_serializing_if = "Option::is_none")]
1250    pub grace_days: Option<i32>,
1251    #[serde(rename = "forkGraceDays", skip_serializing_if = "Option::is_none")]
1252    pub fork_grace_days: Option<i32>,
1253    #[serde(rename = "eventLogDays", skip_serializing_if = "Option::is_none")]
1254    pub event_log_days: Option<i32>,
1255}
1256
1257#[derive(Debug, Clone, Serialize, Deserialize)]
1258pub struct VolumeSizePoint {
1259    #[serde(rename = "bucketEnd")]
1260    pub bucket_end: String,
1261    #[serde(rename = "liveVolume")]
1262    pub live_volume: i64,
1263    #[serde(rename = "totalVolume")]
1264    pub total_volume: i64,
1265    #[serde(rename = "pendingVolume")]
1266    pub pending_volume: i64,
1267    #[serde(rename = "liveInactiveVolume")]
1268    pub live_inactive_volume: i64,
1269}
1270
1271#[derive(Debug, Clone, Serialize, Deserialize)]
1272pub struct VolumeVersioningPolicy {
1273    #[serde(rename = "contentWindowSeconds", skip_serializing_if = "Option::is_none")]
1274    pub content_window_seconds: Option<i32>,
1275}
1276
1277// Accounts
1278
1279#[derive(Debug, Clone, Serialize)]
1280pub struct CreateAccountRequest {
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}
1289
1290#[derive(Debug, Clone, Serialize)]
1291pub struct EditAccountRequest {
1292    pub name: String,
1293    #[serde(skip_serializing_if = "Option::is_none")]
1294    pub description: Option<String>,
1295    #[serde(rename = "iconUrl", skip_serializing_if = "Option::is_none")]
1296    pub icon_url: Option<String>,
1297    #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
1298    pub provider_info: Option<serde_json::Value>,
1299    #[serde(skip_serializing_if = "Option::is_none")]
1300    pub retention: Option<RetentionPolicy>,
1301}
1302
1303#[derive(Debug, Clone, Serialize)]
1304pub struct UpdateAccountQuotaRequest {
1305    #[serde(rename = "quotaLimit")]
1306    pub quota_limit: i64,
1307    #[serde(rename = "quotaExcessPct", skip_serializing_if = "Option::is_none")]
1308    pub quota_excess_pct: Option<i32>,
1309}
1310
1311#[derive(Debug, Clone, Default)]
1312pub struct AccountListOptions {
1313    pub is_active: Option<bool>,
1314    pub page: Option<i64>,
1315    pub limit: Option<i64>,
1316}
1317
1318// Users
1319
1320#[derive(Debug, Clone, Serialize)]
1321pub struct AddUserRequest {
1322    #[serde(rename = "accountId")]
1323    pub account_id: i64,
1324    pub username: String,
1325    pub email: String,
1326    #[serde(skip_serializing_if = "Option::is_none")]
1327    pub name: Option<String>,
1328    #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
1329    pub provider_info: Option<serde_json::Value>,
1330}
1331
1332#[derive(Debug, Clone, Serialize)]
1333pub struct BulkUserRequest {
1334    pub ids: Vec<i64>,
1335}
1336
1337#[derive(Debug, Clone, Serialize, Deserialize)]
1338pub struct BulkUserResponse {
1339    pub users: Vec<UserLite>,
1340}
1341
1342#[derive(Debug, Clone, Serialize)]
1343pub struct EditUserRequest {
1344    pub username: String,
1345    pub email: String,
1346    #[serde(skip_serializing_if = "Option::is_none")]
1347    pub name: Option<String>,
1348    #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
1349    pub provider_info: Option<serde_json::Value>,
1350}
1351
1352#[derive(Debug, Clone, Default)]
1353pub struct UserListOptions {
1354    pub account_id: i64,
1355    pub search: Option<String>,
1356    pub is_active: Option<bool>,
1357    pub page: Option<i64>,
1358    pub limit: Option<i64>,
1359}
1360
1361// Regions
1362
1363#[derive(Debug, Clone, Serialize)]
1364pub struct CreateRegionRequest {
1365    #[serde(rename = "accountId")]
1366    pub account_id: i64,
1367    pub name: String,
1368}
1369
1370#[derive(Debug, Clone, Serialize)]
1371pub struct EditRegionRequest {
1372    #[serde(rename = "accountId")]
1373    pub account_id: i64,
1374    pub name: String,
1375}
1376
1377#[derive(Debug, Clone, Default)]
1378pub struct RegionListOptions {
1379    pub account_id: i64,
1380    pub is_active: Option<bool>,
1381    pub page: Option<i64>,
1382    pub limit: Option<i64>,
1383}
1384
1385// Clusters
1386
1387#[derive(Debug, Clone, Default)]
1388pub struct ClusterListOptions {
1389    pub account_id: i64,
1390    pub region_id: Option<i64>,
1391    pub is_active: Option<bool>,
1392    pub page: Option<i64>,
1393    pub limit: Option<i64>,
1394}
1395
1396// MetadataClusters
1397
1398#[derive(Debug, Clone, Serialize)]
1399pub struct CreateMetadataClusterRequest {
1400    pub name: String,
1401}
1402
1403#[derive(Debug, Clone, Serialize)]
1404pub struct EditMetadataClusterRequest {
1405    pub name: String,
1406}
1407
1408#[derive(Debug, Clone, Serialize)]
1409pub struct SetMetadataClusterReadyRequest {
1410    pub ready: bool,
1411}
1412
1413#[derive(Debug, Clone, Serialize, Deserialize)]
1414pub struct SetReadyMetadataClusterResponse {
1415    pub id: i64,
1416    pub ready: bool,
1417}
1418
1419#[derive(Debug, Clone, Default)]
1420pub struct MetadataClusterListOptions {
1421    pub is_active: Option<bool>,
1422    pub page: Option<i64>,
1423    pub limit: Option<i64>,
1424}
1425
1426// Storages
1427
1428#[derive(Debug, Clone, Serialize)]
1429pub struct CreateStorageRequest {
1430    #[serde(rename = "accountId")]
1431    pub account_id: i64,
1432    #[serde(rename = "regionId")]
1433    pub region_id: i64,
1434    pub name: String,
1435    #[serde(skip_serializing_if = "Option::is_none")]
1436    pub description: Option<String>,
1437    #[serde(rename = "storageType")]
1438    pub storage_type: String,
1439    #[serde(rename = "providerType")]
1440    pub provider_type: String,
1441    pub endpoint: String,
1442    #[serde(skip_serializing_if = "Option::is_none")]
1443    pub region: Option<String>,
1444    #[serde(skip_serializing_if = "Option::is_none")]
1445    pub bucket: Option<String>,
1446    #[serde(skip_serializing_if = "Option::is_none")]
1447    pub base: Option<String>,
1448    #[serde(rename = "blockRegion", skip_serializing_if = "Option::is_none")]
1449    pub block_region: Option<String>,
1450    #[serde(rename = "blockSize", skip_serializing_if = "Option::is_none")]
1451    pub block_size: Option<i32>,
1452    #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none")]
1453    pub access_key: Option<String>,
1454    #[serde(rename = "secretKey", skip_serializing_if = "Option::is_none")]
1455    pub secret_key: Option<String>,
1456}
1457
1458#[derive(Debug, Clone, Serialize)]
1459pub struct EditStorageRequest {
1460    pub name: String,
1461    #[serde(skip_serializing_if = "Option::is_none")]
1462    pub description: Option<String>,
1463    #[serde(skip_serializing_if = "Option::is_none")]
1464    pub endpoint: Option<String>,
1465    #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none")]
1466    pub access_key: Option<String>,
1467    #[serde(rename = "secretKey", skip_serializing_if = "Option::is_none")]
1468    pub secret_key: Option<String>,
1469    #[serde(rename = "directAccess", skip_serializing_if = "Option::is_none")]
1470    pub direct_access: Option<bool>,
1471}
1472
1473#[derive(Debug, Clone, Serialize)]
1474pub struct TestStorageNewBucketRequest {
1475    pub endpoint: String,
1476    #[serde(skip_serializing_if = "Option::is_none")]
1477    pub region: Option<String>,
1478    pub bucket: String,
1479    #[serde(rename = "accessKey")]
1480    pub access_key: String,
1481    #[serde(rename = "secretKey")]
1482    pub secret_key: String,
1483    #[serde(rename = "providerType", skip_serializing_if = "Option::is_none")]
1484    pub provider_type: Option<String>,
1485}
1486
1487#[derive(Debug, Clone, Serialize, Deserialize)]
1488pub struct TestNewBucketStorageResponse {
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 TestStorageBucketStorageResponse {
1500    #[serde(rename = "bucketExists")]
1501    pub bucket_exists: bool,
1502    pub list: bool,
1503    pub write: bool,
1504    pub read: bool,
1505    pub delete: bool,
1506    pub multipart: bool,
1507}
1508
1509#[derive(Debug, Clone, Serialize, Deserialize)]
1510pub struct ListCompatibleStorageResponse {
1511    pub storages: Vec<CompatibleStorage>,
1512}
1513
1514#[derive(Debug, Clone, Serialize)]
1515pub struct MoveStorageVolumesRequest {
1516    #[serde(rename = "volumeIds")]
1517    pub volume_ids: Vec<String>,
1518}
1519
1520#[derive(Debug, Clone, Serialize, Deserialize)]
1521pub struct MoveVolumesStorageResponse {
1522    pub moved: Vec<String>,
1523    pub failures: Vec<MoveVolumeFailure>,
1524}
1525
1526#[derive(Debug, Clone, Serialize)]
1527pub struct DrainStorageCopysetRequest {
1528    #[serde(skip_serializing_if = "Option::is_none")]
1529    pub force: Option<bool>,
1530}
1531
1532#[derive(Debug, Clone, Serialize, Deserialize)]
1533pub struct DrainCopysetStorageResponse {
1534    pub id: String,
1535    pub state: String,
1536}
1537
1538#[derive(Debug, Clone, Serialize)]
1539pub struct CancelStorageDrainRequest {
1540    #[serde(skip_serializing_if = "Option::is_none")]
1541    pub force: Option<bool>,
1542}
1543
1544#[derive(Debug, Clone, Serialize, Deserialize)]
1545pub struct CancelDrainStorageResponse {
1546    pub id: String,
1547    pub state: String,
1548}
1549
1550#[derive(Debug, Clone, Serialize)]
1551pub struct UpdateStorageTagsRequest {
1552    #[serde(skip_serializing_if = "Option::is_none")]
1553    pub tags: Option<Vec<String>>,
1554}
1555
1556#[derive(Debug, Clone, Serialize)]
1557pub struct RegisterStorageCopysetRequest {
1558    #[serde(skip_serializing_if = "Option::is_none")]
1559    pub name: Option<String>,
1560    #[serde(rename = "failureDomainA", skip_serializing_if = "Option::is_none")]
1561    pub failure_domain_a: Option<String>,
1562    #[serde(rename = "failureDomainB", skip_serializing_if = "Option::is_none")]
1563    pub failure_domain_b: Option<String>,
1564}
1565
1566#[derive(Debug, Clone, Serialize)]
1567pub struct RegisterStorageCopysetsBulkRequest {
1568    pub count: i32,
1569    #[serde(rename = "failureDomainA", skip_serializing_if = "Option::is_none")]
1570    pub failure_domain_a: Option<String>,
1571    #[serde(rename = "failureDomainB", skip_serializing_if = "Option::is_none")]
1572    pub failure_domain_b: Option<String>,
1573}
1574
1575#[derive(Debug, Clone, Serialize, Deserialize)]
1576pub struct RegisterCopysetsBulkStorageResponse {
1577    pub copysets: Vec<Copyset>,
1578}
1579
1580#[derive(Debug, Clone, Serialize)]
1581pub struct AddStorageCopysetMemberRequest {
1582    #[serde(rename = "failureDomain", skip_serializing_if = "Option::is_none")]
1583    pub failure_domain: Option<String>,
1584}
1585
1586#[derive(Debug, Clone, Serialize)]
1587pub struct MarkStorageMemberLostRequest {
1588    #[serde(rename = "blockVolumeId")]
1589    pub block_volume_id: String,
1590    #[serde(skip_serializing_if = "Option::is_none")]
1591    pub force: Option<bool>,
1592}
1593
1594#[derive(Debug, Clone, Serialize, Deserialize)]
1595pub struct RemoveMemberStorageResponse {
1596    pub id: String,
1597}
1598
1599#[derive(Debug, Clone, Serialize, Deserialize)]
1600pub struct BackfillFingerprintsStorageResponse {
1601    pub scanned: i32,
1602    pub updated: i32,
1603    pub failures: Vec<BackfillFailure>,
1604    #[serde(rename = "hasMore")]
1605    pub has_more: bool,
1606}
1607
1608#[derive(Debug, Clone, Default)]
1609pub struct StorageListOptions {
1610    pub account_id: i64,
1611    pub search: Option<String>,
1612    pub region_id: Option<i64>,
1613    pub storage_type: Option<String>,
1614    pub provider_type: Option<String>,
1615    pub is_active: Option<bool>,
1616    pub direct_access: Option<bool>,
1617    pub page: Option<i64>,
1618    pub limit: Option<i64>,
1619}
1620
1621// Volumes
1622
1623#[derive(Debug, Clone, Serialize)]
1624pub struct CreateVolumeRequest {
1625    #[serde(rename = "accountId")]
1626    pub account_id: i64,
1627    #[serde(rename = "storageId")]
1628    pub storage_id: i64,
1629    pub name: String,
1630    #[serde(skip_serializing_if = "Option::is_none")]
1631    pub description: Option<String>,
1632    #[serde(rename = "volumeType")]
1633    pub volume_type: String,
1634    #[serde(skip_serializing_if = "Option::is_none")]
1635    pub encryption: Option<bool>,
1636    #[serde(rename = "encryptionKey", skip_serializing_if = "Option::is_none")]
1637    pub encryption_key: Option<String>,
1638    #[serde(skip_serializing_if = "Option::is_none")]
1639    pub retention: Option<VolumeRetentionPolicy>,
1640    #[serde(skip_serializing_if = "Option::is_none")]
1641    pub versioning: Option<VolumeVersioningPolicy>,
1642    #[serde(skip_serializing_if = "Option::is_none")]
1643    pub compaction: Option<String>,
1644    #[serde(rename = "quotaLimit", skip_serializing_if = "Option::is_none")]
1645    pub quota_limit: Option<i64>,
1646    #[serde(rename = "metadataClusterId", skip_serializing_if = "Option::is_none")]
1647    pub metadata_cluster_id: Option<i64>,
1648    #[serde(rename = "metadataClusterUuid", skip_serializing_if = "Option::is_none")]
1649    pub metadata_cluster_uuid: Option<String>,
1650}
1651
1652#[derive(Debug, Clone, Serialize, Deserialize)]
1653pub struct CreateVolumeResponse {
1654    pub id: i64,
1655    #[serde(rename = "encryptionKey", skip_serializing_if = "Option::is_none")]
1656    pub encryption_key: Option<String>,
1657}
1658
1659#[derive(Debug, Clone, Serialize)]
1660pub struct EditVolumeRequest {
1661    #[serde(skip_serializing_if = "Option::is_none")]
1662    pub description: Option<String>,
1663    #[serde(skip_serializing_if = "Option::is_none")]
1664    pub retention: Option<VolumeRetentionPolicy>,
1665    #[serde(skip_serializing_if = "Option::is_none")]
1666    pub versioning: Option<VolumeVersioningPolicy>,
1667    #[serde(skip_serializing_if = "Option::is_none")]
1668    pub compaction: Option<String>,
1669}
1670
1671#[derive(Debug, Clone, Serialize)]
1672pub struct MoveVolumeClusterRequest {
1673    #[serde(rename = "targetClusterId", skip_serializing_if = "Option::is_none")]
1674    pub target_cluster_id: Option<i64>,
1675    #[serde(rename = "targetClusterUuid", skip_serializing_if = "Option::is_none")]
1676    pub target_cluster_uuid: Option<String>,
1677}
1678
1679#[derive(Debug, Clone, Serialize, Deserialize)]
1680pub struct MoveClusterVolumeResponse {
1681    pub id: i64,
1682    #[serde(rename = "sourceClusterId")]
1683    pub source_cluster_id: i64,
1684    #[serde(rename = "targetClusterId")]
1685    pub target_cluster_id: i64,
1686    #[serde(rename = "handoverUntil")]
1687    pub handover_until: i64,
1688}
1689
1690#[derive(Debug, Clone, Serialize)]
1691pub struct DeactivateVolumeRequest {
1692    #[serde(rename = "isCleanupMetaEnabled", skip_serializing_if = "Option::is_none")]
1693    pub is_cleanup_meta_enabled: Option<bool>,
1694    #[serde(rename = "isCleanupStorageEnabled", skip_serializing_if = "Option::is_none")]
1695    pub is_cleanup_storage_enabled: Option<bool>,
1696    #[serde(rename = "isCleanupVaultEnabled", skip_serializing_if = "Option::is_none")]
1697    pub is_cleanup_vault_enabled: Option<bool>,
1698}
1699
1700#[derive(Debug, Clone, Serialize)]
1701pub struct GenerateVolumeAPIKeysRequest {
1702    #[serde(rename = "userId")]
1703    pub user_id: i64,
1704    #[serde(skip_serializing_if = "Option::is_none")]
1705    pub name: Option<String>,
1706}
1707
1708#[derive(Debug, Clone, Serialize, Deserialize)]
1709pub struct GenerateAPIKeysVolumeResponse {
1710    #[serde(rename = "apiKey")]
1711    pub api_key: String,
1712    #[serde(rename = "apiSecret")]
1713    pub api_secret: String,
1714    #[serde(rename = "evictedApiKeys", skip_serializing_if = "Option::is_none")]
1715    pub evicted_api_keys: Option<Vec<String>>,
1716}
1717
1718#[derive(Debug, Clone, Serialize, Deserialize)]
1719pub struct ListAPIKeysVolumeResponse {
1720    pub keys: Vec<VolumeApiKey>,
1721}
1722
1723#[derive(Debug, Clone, Serialize)]
1724pub struct RevokeVolumeAPIKeyRequest {
1725    #[serde(rename = "apiKey")]
1726    pub api_key: String,
1727}
1728
1729#[derive(Debug, Clone, Serialize)]
1730pub struct RevokeVolumeAPIKeysByUserRequest {
1731    #[serde(rename = "userId")]
1732    pub user_id: i64,
1733}
1734
1735#[derive(Debug, Clone, Serialize)]
1736pub struct GenerateVolumeSttKeyRequest {
1737    #[serde(rename = "userId", skip_serializing_if = "Option::is_none")]
1738    pub user_id: Option<i64>,
1739    #[serde(rename = "expirySeconds")]
1740    pub expiry_seconds: i64,
1741}
1742
1743#[derive(Debug, Clone, Serialize, Deserialize)]
1744pub struct GenerateSttKeyVolumeResponse {
1745    #[serde(rename = "apiKey")]
1746    pub api_key: String,
1747    #[serde(rename = "apiSecret")]
1748    pub api_secret: String,
1749    #[serde(rename = "expiresAt")]
1750    pub expires_at: String,
1751}
1752
1753#[derive(Debug, Clone, Serialize)]
1754pub struct UpdateVolumeQuotaRequest {
1755    #[serde(rename = "quotaLimit")]
1756    pub quota_limit: i64,
1757}
1758
1759#[derive(Debug, Clone, Serialize)]
1760pub struct UpdateVolumeCopysetConfigRequest {
1761    #[serde(rename = "targetCopysetCount")]
1762    pub target_copyset_count: i32,
1763}
1764
1765#[derive(Debug, Clone, Serialize, Deserialize)]
1766pub struct StatsVolumeResponse {
1767    #[serde(rename = "volumeId")]
1768    pub volume_id: String,
1769    #[serde(rename = "liveVolume")]
1770    pub live_volume: i64,
1771    #[serde(rename = "totalVolume")]
1772    pub total_volume: i64,
1773    #[serde(rename = "pendingVolume")]
1774    pub pending_volume: i64,
1775    #[serde(rename = "liveInactiveVolume")]
1776    pub live_inactive_volume: i64,
1777}
1778
1779#[derive(Debug, Clone, Serialize, Deserialize)]
1780pub struct SizeHistoryVolumeResponse {
1781    pub points: Vec<VolumeSizePoint>,
1782}
1783
1784#[derive(Debug, Clone, Serialize)]
1785pub struct CreateVolumeForkRequest {
1786    pub name: String,
1787    #[serde(rename = "parentName", skip_serializing_if = "Option::is_none")]
1788    pub parent_name: Option<String>,
1789    #[serde(rename = "asOf", skip_serializing_if = "Option::is_none")]
1790    pub as_of: Option<i64>,
1791    #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1792    pub volume_type: Option<String>,
1793}
1794
1795#[derive(Debug, Clone, Serialize)]
1796pub struct DeleteVolumeForkRequest {
1797    #[serde(skip_serializing_if = "Option::is_none")]
1798    pub force: Option<bool>,
1799    #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1800    pub volume_type: Option<String>,
1801}
1802
1803#[derive(Debug, Clone, Serialize, Deserialize)]
1804pub struct DeleteForkVolumeResponse {
1805    #[serde(rename = "inactivatedFids")]
1806    pub inactivated_fids: Vec<i32>,
1807}
1808
1809#[derive(Debug, Clone, Serialize)]
1810pub struct RestoreVolumeForkRequest {
1811    #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1812    pub volume_type: Option<String>,
1813}
1814
1815#[derive(Debug, Clone, Default)]
1816pub struct VolumeListOptions {
1817    pub account_id: i64,
1818    pub region_id: Option<i64>,
1819    pub metadata_cluster_id: Option<i64>,
1820    pub storage_id: Option<i64>,
1821    pub volume_type: Option<String>,
1822    pub locked: Option<bool>,
1823    pub is_active: Option<bool>,
1824    pub page: Option<i64>,
1825    pub limit: Option<i64>,
1826}
1827
1828// VolumeForkTrees
1829
1830#[derive(Debug, Clone, Default)]
1831pub struct VolumeForkTreeListOptions {
1832    pub path: Option<String>,
1833    pub as_of: Option<i64>,
1834    pub cursor: Option<String>,
1835    pub limit: Option<i64>,
1836    pub sort: Option<String>,
1837    pub kind: Option<String>,
1838}
1839
1840// VolumeForkEntries
1841
1842#[derive(Debug, Clone, Default)]
1843pub struct VolumeForkEntryListOptions {
1844    pub path: Option<String>,
1845    pub cursor: Option<i64>,
1846    pub limit: Option<i64>,
1847}
1848
1849// VolumeForkSearches
1850
1851#[derive(Debug, Clone, Default)]
1852pub struct VolumeForkSearchListOptions {
1853    pub q: Option<String>,
1854    pub path: Option<String>,
1855    pub as_of: Option<i64>,
1856    pub exact: Option<bool>,
1857    pub cursor: Option<i64>,
1858    pub limit: Option<i64>,
1859    pub kind: Option<String>,
1860}
1861
1862// AuditLogs
1863
1864#[derive(Debug, Clone, Default)]
1865pub struct AuditLogListOptions {
1866    pub account_id: i64,
1867    pub region_id: Option<i64>,
1868    pub metadata_cluster_id: Option<i64>,
1869    pub cursor: Option<i64>,
1870    pub limit: Option<i64>,
1871    pub subject: Option<String>,
1872    pub created_by: Option<String>,
1873}
1874
1875// RegionAuditLogs
1876
1877#[derive(Debug, Clone, Default)]
1878pub struct RegionAuditLogListOptions {
1879    pub metadata_cluster_id: Option<i64>,
1880    pub cursor: Option<i64>,
1881    pub limit: Option<i64>,
1882    pub subject: Option<String>,
1883    pub node: Option<String>,
1884}
1885
1886// ServiceNodes
1887
1888#[derive(Debug, Clone, Serialize, Deserialize)]
1889pub struct StatsHistoryServiceNodeResponse {
1890    #[serde(rename = "intervalMs")]
1891    pub interval_ms: i64,
1892    pub samples: Vec<NodeStatsSample>,
1893}
1894
1895// Nodes
1896
1897// ClientSessions
1898
1899#[derive(Debug, Clone, Default)]
1900pub struct ClientSessionListOptions {
1901    pub account_id: i64,
1902    pub region_id: Option<i64>,
1903    pub metadata_cluster_id: Option<i64>,
1904    pub volume_id: Option<i64>,
1905    pub user_id: Option<i64>,
1906    pub client_type: Option<String>,
1907    pub status: Option<ClientSessionStatus>,
1908    pub is_active: Option<bool>,
1909    pub os_name: Option<String>,
1910    pub platform: Option<String>,
1911    pub search: Option<String>,
1912    pub page: Option<i64>,
1913    pub limit: Option<i64>,
1914}
1915
1916// Discover
1917
1918// Metrics
1919
1920#[derive(Debug, Clone, Serialize)]
1921pub struct GenerateMetricTokenRequest {
1922    #[serde(rename = "expirySeconds")]
1923    pub expiry_seconds: i64,
1924}
1925
1926// Dashboard
1927
1928// License
1929
1930#[derive(Debug, Clone, Serialize)]
1931pub struct LoadLicenseRequest {
1932    pub payloads: Vec<String>,
1933}
1934
1935// Alerts
1936
1937#[derive(Debug, Clone, Serialize, Deserialize)]
1938pub struct ResolveAlertResponse {
1939    #[serde(rename = "alertId")]
1940    pub alert_id: String,
1941}
1942
1943#[derive(Debug, Clone, Default)]
1944pub struct AlertListOptions {
1945    pub active: Option<bool>,
1946    pub account_id: Option<i64>,
1947    pub region_id: Option<i64>,
1948    pub severity: Option<i64>,
1949    pub category: Option<String>,
1950    pub since: Option<String>,
1951    pub page: Option<i64>,
1952    pub limit: Option<i64>,
1953}
1954
1955// RegionAlerts
1956
1957#[derive(Debug, Clone, Serialize, Deserialize)]
1958pub struct ResolveRegionAlertResponse {
1959    #[serde(rename = "alertId")]
1960    pub alert_id: String,
1961}
1962
1963#[derive(Debug, Clone, Default)]
1964pub struct RegionAlertListOptions {
1965    pub active: Option<bool>,
1966    pub severity: Option<i64>,
1967    pub category: Option<String>,
1968    pub node_id: Option<String>,
1969    pub metadata_cluster_id: Option<i64>,
1970    pub since: Option<String>,
1971    pub page: Option<i64>,
1972    pub limit: Option<i64>,
1973}
1974
1975// GCWorkerEvents
1976
1977#[derive(Debug, Clone, Default)]
1978pub struct GCWorkerEventListOptions {
1979    pub node_id: Option<String>,
1980    pub goal: Option<String>,
1981    pub sid: Option<i64>,
1982    pub metadata_cluster_id: Option<i64>,
1983    pub since: Option<String>,
1984    pub page: Option<i64>,
1985    pub limit: Option<i64>,
1986}
1987
1988// Vault
mountos_admin_sdk/types_gen.rs

mountos_admin_sdk/
types_gen.rs
