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

mountos_admin_sdk/
types_gen.rs
