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

mountos_admin_sdk/
types_gen.rs
