1use serde::{Deserialize, Serialize};
4
5#[derive(Debug, Clone, Default)]
7pub struct Config {
8 pub base_url: String,
10 pub private_key: String,
12 pub dashboard_user: Option<DashboardUser>,
14}
15
16#[derive(Debug, Clone, Default)]
18pub struct ListOptions {
19 pub page: Option<i64>,
20 pub limit: Option<i64>,
21}
22
23#[derive(Debug, Clone, Deserialize)]
25pub struct PaginationMeta {
26 pub page: i64,
27 pub limit: i64,
28 pub total: i64,
29 #[serde(rename = "totalPages")]
30 pub total_pages: i64,
31}
32
33#[derive(Debug, Clone, Deserialize)]
35pub struct PaginatedResponse<T> {
36 pub items: Vec<T>,
37 pub pagination: PaginationMeta,
38}
39
40#[derive(Debug, Clone, Deserialize)]
42pub struct CursorPaginatedResponse<T> {
43 pub items: Vec<T>,
44 #[serde(rename = "nextCursor")]
45 pub next_cursor: Option<i64>,
46}
47
48#[derive(Debug, Clone, Deserialize)]
50pub struct IdResponse {
51 pub id: i64,
52}
53
54pub type ClientSessionStatus = String;
56pub const CLIENT_SESSION_STATUS_CONNECTED: &str = "connected";
57pub const CLIENT_SESSION_STATUS_ACTIVE: &str = "active";
58pub const CLIENT_SESSION_STATUS_UNHEALTHY: &str = "unhealthy";
59pub const CLIENT_SESSION_STATUS_DISCONNECTED: &str = "disconnected";
60pub const CLIENT_SESSION_STATUS_EXPIRED: &str = "expired";
61pub const CLIENT_SESSION_STATUS_UNKNOWN: &str = "unknown";
62
63pub type LicenseQuotaState = String;
65pub const LICENSE_QUOTA_STATE_OK: &str = "ok";
66pub const LICENSE_QUOTA_STATE_EXCEEDED: &str = "exceeded";
67
68pub type LicenseStatus = String;
70pub const LICENSE_STATUS_VALID: &str = "valid";
71pub const LICENSE_STATUS_EXPIRING: &str = "expiring";
72pub const LICENSE_STATUS_GRACE: &str = "grace";
73pub const LICENSE_STATUS_EXPIRED_ACCESS: &str = "expired_access";
74pub const LICENSE_STATUS_EXPIRED: &str = "expired";
75
76#[derive(Debug, Clone, Serialize, Deserialize)]
77pub struct Account {
78 pub id: i64,
79 pub name: String,
80 pub description: String,
81 #[serde(rename = "iconUrl", skip_serializing_if = "Option::is_none")]
82 pub icon_url: Option<String>,
83 #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
84 pub provider_info: Option<serde_json::Value>,
85 #[serde(rename = "liveVolume")]
86 pub live_volume: i64,
87 #[serde(rename = "totalVolume")]
88 pub total_volume: i64,
89 #[serde(rename = "quotaLimit")]
90 pub quota_limit: i64,
91 #[serde(rename = "quotaExcessPct")]
92 pub quota_excess_pct: i32,
93 #[serde(rename = "isActive")]
94 pub is_active: bool,
95 pub locked: bool,
96 #[serde(rename = "createdAt")]
97 pub created_at: String,
98 #[serde(rename = "updatedAt")]
99 pub updated_at: String,
100}
101
102#[derive(Debug, Clone, Serialize, Deserialize)]
103pub struct User {
104 pub id: i64,
105 #[serde(rename = "accountId")]
106 pub account_id: i64,
107 pub username: String,
108 pub email: String,
109 pub name: String,
110 #[serde(rename = "isActive")]
111 pub is_active: bool,
112}
113
114#[derive(Debug, Clone, Serialize, Deserialize)]
115pub struct Region {
116 pub id: i64,
117 #[serde(rename = "exportId")]
118 pub export_id: String,
119 #[serde(rename = "accountId")]
120 pub account_id: i64,
121 pub name: String,
122 pub dns: String,
123 #[serde(rename = "liveVolume")]
124 pub live_volume: i64,
125 #[serde(rename = "totalVolume")]
126 pub total_volume: i64,
127 #[serde(rename = "isActive")]
128 pub is_active: bool,
129 #[serde(rename = "createdAt")]
130 pub created_at: String,
131 #[serde(rename = "updatedAt")]
132 pub updated_at: String,
133}
134
135#[derive(Debug, Clone, Serialize, Deserialize)]
136pub struct RegionCluster {
137 pub id: i64,
138 #[serde(rename = "exportId")]
139 pub export_id: String,
140 #[serde(rename = "regionId")]
141 pub region_id: i64,
142 pub name: String,
143 #[serde(rename = "defaultCluster")]
144 pub default_cluster: bool,
145 #[serde(rename = "isReady")]
146 pub is_ready: bool,
147 #[serde(rename = "isActive")]
148 pub is_active: bool,
149 #[serde(rename = "createdAt")]
150 pub created_at: String,
151 #[serde(rename = "updatedAt")]
152 pub updated_at: String,
153}
154
155#[derive(Debug, Clone, Serialize, Deserialize)]
156pub struct Storage {
157 pub id: i64,
158 pub account: Ref,
159 #[serde(rename = "regionInfo")]
160 pub region_info: Ref,
161 pub name: String,
162 #[serde(skip_serializing_if = "Option::is_none")]
163 pub description: Option<String>,
164 #[serde(rename = "storageType")]
165 pub storage_type: String,
166 #[serde(rename = "providerType")]
167 pub provider_type: String,
168 #[serde(rename = "blockType", skip_serializing_if = "Option::is_none")]
169 pub block_type: Option<String>,
170 pub endpoint: String,
171 #[serde(skip_serializing_if = "Option::is_none")]
172 pub region: Option<String>,
173 #[serde(skip_serializing_if = "Option::is_none")]
174 pub bucket: Option<String>,
175 #[serde(skip_serializing_if = "Option::is_none")]
176 pub base: Option<String>,
177 #[serde(rename = "blockRegion", skip_serializing_if = "Option::is_none")]
178 pub block_region: Option<String>,
179 #[serde(rename = "blockSize", skip_serializing_if = "Option::is_none")]
180 pub block_size: Option<i32>,
181 #[serde(rename = "isActive")]
182 pub is_active: bool,
183 #[serde(rename = "createdAt")]
184 pub created_at: String,
185 #[serde(rename = "updatedAt")]
186 pub updated_at: String,
187}
188
189#[derive(Debug, Clone, Serialize, Deserialize)]
190pub struct Volume {
191 pub id: i64,
192 pub account: Ref,
193 pub storage: Ref,
194 pub region: Ref,
195 #[serde(rename = "regionCluster", skip_serializing_if = "Option::is_none")]
196 pub region_cluster: Option<Ref>,
197 pub name: String,
198 #[serde(skip_serializing_if = "Option::is_none")]
199 pub description: Option<String>,
200 #[serde(rename = "volumeType")]
201 pub volume_type: String,
202 pub encryption: bool,
203 #[serde(rename = "quotaLimit")]
204 pub quota_limit: i64,
205 #[serde(rename = "liveVolume")]
206 pub live_volume: i64,
207 #[serde(rename = "totalVolume")]
208 pub total_volume: i64,
209 #[serde(rename = "pendingVolume")]
210 pub pending_volume: i64,
211 #[serde(rename = "liveInactiveVolume")]
212 pub live_inactive_volume: i64,
213 pub locked: bool,
214 #[serde(rename = "retentionPeriod")]
215 pub retention_period: i32,
216 #[serde(rename = "gracePeriod")]
217 pub grace_period: i32,
218 #[serde(rename = "forkGracePeriod")]
219 pub fork_grace_period: i32,
220 #[serde(rename = "eventLogRetentionPeriod")]
221 pub event_log_retention_period: i32,
222 #[serde(rename = "isActive")]
223 pub is_active: bool,
224 #[serde(rename = "isCleanupMetaEnabled")]
225 pub is_cleanup_meta_enabled: bool,
226 #[serde(rename = "isCleanupStorageEnabled")]
227 pub is_cleanup_storage_enabled: bool,
228 #[serde(rename = "isCleanupVaultEnabled")]
229 pub is_cleanup_vault_enabled: bool,
230 #[serde(rename = "createdAt")]
231 pub created_at: String,
232 #[serde(rename = "updatedAt")]
233 pub updated_at: String,
234}
235
236#[derive(Debug, Clone, Serialize, Deserialize)]
237pub struct Fork {
238 pub fid: i32,
239 pub name: String,
240 #[serde(rename = "parentFid")]
241 pub parent_fid: i32,
242 #[serde(rename = "parentName")]
243 pub parent_name: String,
244 #[serde(rename = "snapshotTs")]
245 pub snapshot_ts: i64,
246 #[serde(rename = "createdBy", skip_serializing_if = "Option::is_none")]
247 pub created_by: Option<i64>,
248 #[serde(rename = "createdAt")]
249 pub created_at: i64,
250 #[serde(rename = "childrenCount")]
251 pub children_count: i32,
252 #[serde(skip_serializing_if = "Option::is_none")]
253 pub inactive: Option<bool>,
254 #[serde(rename = "inactiveAt", skip_serializing_if = "Option::is_none")]
255 pub inactive_at: Option<i64>,
256 pub status: String,
257 pub size: i64,
258}
259
260#[derive(Debug, Clone, Serialize, Deserialize)]
261pub struct ForkTreeEntry {
262 pub inode: i64,
263 pub name: String,
264 pub kind: String,
265 pub size: i64,
266 pub mtime: i64,
267 pub ctime: i64,
268 #[serde(rename = "creatorId", skip_serializing_if = "Option::is_none")]
269 pub creator_id: Option<i64>,
270 #[serde(rename = "updaterId", skip_serializing_if = "Option::is_none")]
271 pub updater_id: Option<i64>,
272}
273
274#[derive(Debug, Clone, Serialize, Deserialize)]
275pub struct ForkEntryDetail {
276 pub inode: i64,
277 pub path: String,
278 pub name: String,
279 pub kind: String,
280 pub size: i64,
281 pub mtime: i64,
282 pub ctime: i64,
283 pub generation: i64,
284 #[serde(skip_serializing_if = "Option::is_none")]
285 pub owner: Option<String>,
286 #[serde(skip_serializing_if = "Option::is_none")]
287 pub mode: Option<i32>,
288 #[serde(skip_serializing_if = "Option::is_none")]
289 pub xattrs: Option<serde_json::Value>,
290 #[serde(rename = "creatorId", skip_serializing_if = "Option::is_none")]
291 pub creator_id: Option<i64>,
292 #[serde(rename = "updaterId", skip_serializing_if = "Option::is_none")]
293 pub updater_id: Option<i64>,
294}
295
296#[derive(Debug, Clone, Serialize, Deserialize)]
297pub struct ForkEntryVersion {
298 pub generation: i64,
299 pub size: i64,
300 pub mtime: i64,
301 #[serde(rename = "updaterId", skip_serializing_if = "Option::is_none")]
302 pub updater_id: Option<i64>,
303 #[serde(rename = "contentHash", skip_serializing_if = "Option::is_none")]
304 pub content_hash: Option<String>,
305}
306
307#[derive(Debug, Clone, Serialize, Deserialize)]
308pub struct ForkTreeMatch {
309 pub path: String,
310 pub inode: i64,
311 pub kind: String,
312 pub size: i64,
313 pub mtime: i64,
314}
315
316#[derive(Debug, Clone, Serialize, Deserialize)]
317pub struct AuditLog {
318 pub id: i64,
319 pub title: String,
320 #[serde(skip_serializing_if = "Option::is_none")]
321 pub description: Option<String>,
322 #[serde(skip_serializing_if = "Option::is_none")]
323 pub subject: Option<String>,
324 pub success: bool,
325 #[serde(skip_serializing_if = "Option::is_none")]
326 pub data: Option<serde_json::Value>,
327 #[serde(rename = "createdBy", skip_serializing_if = "Option::is_none")]
328 pub created_by: Option<String>,
329 #[serde(skip_serializing_if = "Option::is_none")]
330 pub node: Option<String>,
331 #[serde(rename = "accountId", skip_serializing_if = "Option::is_none")]
332 pub account_id: Option<i64>,
333 #[serde(rename = "regionId", skip_serializing_if = "Option::is_none")]
334 pub region_id: Option<i64>,
335 #[serde(rename = "regionClusterId", skip_serializing_if = "Option::is_none")]
336 pub region_cluster_id: Option<i64>,
337 #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
338 pub created_at: Option<String>,
339 #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")]
340 pub updated_at: Option<String>,
341}
342
343#[derive(Debug, Clone, Serialize, Deserialize)]
344pub struct ServiceNode {
345 pub id: i64,
346 #[serde(rename = "regionId")]
347 pub region_id: i64,
348 #[serde(rename = "regionClusterId", skip_serializing_if = "Option::is_none")]
349 pub region_cluster_id: Option<i64>,
350 #[serde(rename = "serviceType")]
351 pub service_type: String,
352 #[serde(rename = "nodeId")]
353 pub node_id: String,
354 #[serde(rename = "advertiseAddr")]
355 pub advertise_addr: String,
356 #[serde(rename = "rpcAddr", skip_serializing_if = "Option::is_none")]
357 pub rpc_addr: Option<String>,
358 #[serde(skip_serializing_if = "Option::is_none")]
359 pub metadata: Option<serde_json::Value>,
360 pub status: String,
361 #[serde(rename = "lastHeartbeat", skip_serializing_if = "Option::is_none")]
362 pub last_heartbeat: Option<i64>,
363 #[serde(rename = "isActive")]
364 pub is_active: bool,
365 #[serde(rename = "memUsage", skip_serializing_if = "Option::is_none")]
366 pub mem_usage: Option<f64>,
367 #[serde(rename = "sysLoad", skip_serializing_if = "Option::is_none")]
368 pub sys_load: Option<i64>,
369}
370
371#[derive(Debug, Clone, Serialize, Deserialize)]
372pub struct ClientSession {
373 pub id: i64,
374 pub account: Ref,
375 pub region: Ref,
376 #[serde(rename = "regionCluster", skip_serializing_if = "Option::is_none")]
377 pub region_cluster: Option<Ref>,
378 pub volume: VolumeRef,
379 #[serde(skip_serializing_if = "Option::is_none")]
380 pub user: Option<Ref>,
381 #[serde(rename = "clientType")]
382 pub client_type: String,
383 #[serde(rename = "osName")]
384 pub os_name: String,
385 #[serde(rename = "osVersion", skip_serializing_if = "Option::is_none")]
386 pub os_version: Option<String>,
387 #[serde(rename = "appVersion", skip_serializing_if = "Option::is_none")]
388 pub app_version: Option<String>,
389 #[serde(skip_serializing_if = "Option::is_none")]
390 pub hostname: Option<String>,
391 #[serde(rename = "ipAddr")]
392 pub ip_addr: String,
393 #[serde(rename = "mountMode", skip_serializing_if = "Option::is_none")]
394 pub mount_mode: Option<String>,
395 #[serde(rename = "mountPath", skip_serializing_if = "Option::is_none")]
396 pub mount_path: Option<String>,
397 #[serde(rename = "forkName", skip_serializing_if = "Option::is_none")]
398 pub fork_name: Option<String>,
399 #[serde(rename = "isTemporaryFork")]
400 pub is_temporary_fork: bool,
401 #[serde(skip_serializing_if = "Option::is_none")]
402 pub metadata: Option<serde_json::Value>,
403 #[serde(skip_serializing_if = "Option::is_none")]
404 pub metrics: Option<serde_json::Value>,
405 pub status: ClientSessionStatus,
406 #[serde(rename = "lastHeartbeat", skip_serializing_if = "Option::is_none")]
407 pub last_heartbeat: Option<i64>,
408 #[serde(rename = "connectedAt", skip_serializing_if = "Option::is_none")]
409 pub connected_at: Option<i64>,
410 #[serde(rename = "disconnectedAt", skip_serializing_if = "Option::is_none")]
411 pub disconnected_at: Option<i64>,
412 #[serde(rename = "isActive")]
413 pub is_active: bool,
414}
415
416#[derive(Debug, Clone, Serialize, Deserialize)]
417pub struct SessionSummary {
418 #[serde(rename = "byStatus")]
419 pub by_status: Vec<SessionSummaryStatusEntry>,
420 #[serde(rename = "byPlatform")]
421 pub by_platform: Vec<SessionSummaryFacet>,
422 #[serde(rename = "byOsName")]
423 pub by_os_name: Vec<SessionSummaryFacet>,
424 #[serde(rename = "regionCount")]
425 pub region_count: i64,
426 #[serde(rename = "volumeCount")]
427 pub volume_count: i64,
428 #[serde(rename = "hostCount")]
429 pub host_count: i64,
430 #[serde(rename = "unhealthyCount")]
431 pub unhealthy_count: i64,
432}
433
434#[derive(Debug, Clone, Serialize, Deserialize)]
435pub struct DiscoverMetaResponse {
436 #[serde(rename = "regionId")]
437 pub region_id: i64,
438 pub region: String,
439 pub endpoints: Vec<DiscoverEndpoint>,
440}
441
442#[derive(Debug, Clone, Serialize, Deserialize)]
443pub struct DashboardStats {
444 #[serde(rename = "userCount")]
445 pub user_count: i64,
446 #[serde(rename = "volumeCount")]
447 pub volume_count: i64,
448 #[serde(rename = "regionCount")]
449 pub region_count: i64,
450 #[serde(rename = "storageCount")]
451 pub storage_count: i64,
452 #[serde(rename = "totalVolumeUsed")]
453 pub total_volume_used: i64,
454 #[serde(rename = "totalQuotaLimit")]
455 pub total_quota_limit: i64,
456 #[serde(rename = "activeSessionCount")]
457 pub active_session_count: i64,
458 #[serde(rename = "regionBreakdown")]
459 pub region_breakdown: Vec<RegionVolumeMetrics>,
460}
461
462#[derive(Debug, Clone, Serialize, Deserialize)]
463pub struct LicenseDetails {
464 #[serde(rename = "licenseId")]
465 pub license_id: String,
466 pub licensee: String,
467 pub contact: String,
468 #[serde(rename = "licenseType")]
469 pub license_type: String,
470 #[serde(rename = "issuedAt")]
471 pub issued_at: String,
472 #[serde(rename = "expiresAt")]
473 pub expires_at: String,
474 #[serde(rename = "gracePeriodDays")]
475 pub grace_period_days: i64,
476 #[serde(rename = "expiredAccessDays")]
477 pub expired_access_days: i64,
478 #[serde(rename = "maxNodes")]
479 pub max_nodes: i64,
480 #[serde(rename = "maxVolumes")]
481 pub max_volumes: i64,
482 #[serde(rename = "maxUsers")]
483 pub max_users: i64,
484 #[serde(rename = "maxAccounts")]
485 pub max_accounts: i64,
486 #[serde(rename = "maxRegions")]
487 pub max_regions: i64,
488 #[serde(rename = "maxStorageBytes")]
489 pub max_storage_bytes: i64,
490 pub status: LicenseStatus,
491 #[serde(rename = "daysRemaining")]
492 pub days_remaining: i64,
493 #[serde(rename = "graceEndsAt")]
494 pub grace_ends_at: String,
495 #[serde(rename = "graceDaysLeft")]
496 pub grace_days_left: i64,
497 #[serde(rename = "expiredAccessEndsAt")]
498 pub expired_access_ends_at: String,
499 #[serde(rename = "expiredAccessDaysLeft")]
500 pub expired_access_days_left: i64,
501 pub quota: LicenseQuota,
502}
503
504#[derive(Debug, Clone, Serialize, Deserialize)]
505pub struct LicenseTerms {
506 pub terms: String,
507}
508
509#[derive(Debug, Clone, Serialize, Deserialize)]
510pub struct ServiceAlert {
511 pub id: i64,
512 #[serde(rename = "alertId")]
513 pub alert_id: String,
514 pub source: String,
515 #[serde(rename = "nodeId")]
516 pub node_id: String,
517 pub severity: i64,
518 pub category: String,
519 pub title: String,
520 #[serde(skip_serializing_if = "Option::is_none")]
521 pub description: Option<String>,
522 #[serde(skip_serializing_if = "Option::is_none")]
523 pub region: Option<Ref>,
524 #[serde(skip_serializing_if = "Option::is_none")]
525 pub account: Option<Ref>,
526 #[serde(rename = "eventTime")]
527 pub event_time: String,
528 #[serde(rename = "resolvedAt", skip_serializing_if = "Option::is_none")]
529 pub resolved_at: Option<String>,
530 #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
531 pub created_at: Option<String>,
532}
533
534#[derive(Debug, Clone, Serialize, Deserialize)]
535pub struct AlertCountResponse {
536 pub active: i64,
537 pub recent: i64,
538 #[serde(rename = "infoCount")]
539 pub info_count: i64,
540 #[serde(rename = "warningCount")]
541 pub warning_count: i64,
542 #[serde(rename = "criticalCount")]
543 pub critical_count: i64,
544}
545
546#[derive(Debug, Clone, Serialize, Deserialize)]
547pub struct RegionAlert {
548 pub id: i64,
549 #[serde(rename = "alertId")]
550 pub alert_id: String,
551 pub source: String,
552 #[serde(rename = "nodeId")]
553 pub node_id: String,
554 #[serde(rename = "regionClusterId", skip_serializing_if = "Option::is_none")]
555 pub region_cluster_id: Option<i64>,
556 pub severity: i64,
557 pub category: String,
558 pub title: String,
559 #[serde(skip_serializing_if = "Option::is_none")]
560 pub description: Option<String>,
561 #[serde(rename = "eventTime")]
562 pub event_time: String,
563 #[serde(rename = "resolvedAt", skip_serializing_if = "Option::is_none")]
564 pub resolved_at: Option<String>,
565 #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
566 pub created_at: Option<String>,
567}
568
569#[derive(Debug, Clone, Serialize, Deserialize)]
570pub struct DashboardUser {
571 pub id: String,
572 pub name: String,
573 #[serde(skip_serializing_if = "Option::is_none")]
574 pub email: Option<String>,
575 pub role: String,
576 #[serde(skip_serializing_if = "Option::is_none")]
577 pub username: Option<String>,
578 #[serde(rename = "accountId", skip_serializing_if = "Option::is_none")]
579 pub account_id: Option<i64>,
580 #[serde(rename = "userId", skip_serializing_if = "Option::is_none")]
581 pub user_id: Option<i64>,
582 #[serde(rename = "volumeId", skip_serializing_if = "Option::is_none")]
583 pub volume_id: Option<i64>,
584 #[serde(skip_serializing_if = "Option::is_none")]
585 pub exp: Option<i64>,
586}
587
588#[derive(Debug, Clone, Serialize, Deserialize)]
589pub struct DiscoverEndpoint {
590 #[serde(rename = "nodeId")]
591 pub node_id: String,
592 pub addr: String,
593 pub status: String,
594}
595
596#[derive(Debug, Clone, Serialize, Deserialize)]
597pub struct LicenseQuota {
598 pub state: LicenseQuotaState,
599 #[serde(rename = "liveVolume")]
600 pub live_volume: i64,
601 #[serde(rename = "totalVolume")]
602 pub total_volume: i64,
603 pub generation: i64,
604 #[serde(rename = "lastTransitionAtMs")]
605 pub last_transition_at_ms: i64,
606}
607
608#[derive(Debug, Clone, Serialize, Deserialize)]
609pub struct Ref {
610 pub id: i64,
611 pub name: String,
612}
613
614#[derive(Debug, Clone, Serialize, Deserialize)]
615pub struct RegionVolumeMetrics {
616 #[serde(rename = "regionId")]
617 pub region_id: i64,
618 #[serde(rename = "regionName")]
619 pub region_name: String,
620 #[serde(rename = "volumeCount")]
621 pub volume_count: i64,
622 #[serde(rename = "totalVolumeUsed")]
623 pub total_volume_used: i64,
624 #[serde(rename = "totalQuotaLimit")]
625 pub total_quota_limit: i64,
626}
627
628#[derive(Debug, Clone, Serialize, Deserialize)]
629pub struct SessionSummaryFacet {
630 pub label: String,
631 pub count: i64,
632}
633
634#[derive(Debug, Clone, Serialize, Deserialize)]
635pub struct SessionSummaryStatusEntry {
636 #[serde(rename = "clientType")]
637 pub client_type: String,
638 pub status: String,
639 pub count: i64,
640}
641
642#[derive(Debug, Clone, Serialize, Deserialize)]
643pub struct UserLite {
644 pub id: i64,
645 pub username: String,
646 pub name: String,
647}
648
649#[derive(Debug, Clone, Serialize, Deserialize)]
650pub struct VolumeRef {
651 pub id: i64,
652 pub name: String,
653 #[serde(skip_serializing_if = "Option::is_none")]
654 pub r#type: Option<String>,
655}
656
657#[derive(Debug, Clone, Serialize, Deserialize)]
658pub struct VolumeSizePoint {
659 #[serde(rename = "bucketEnd")]
660 pub bucket_end: String,
661 #[serde(rename = "liveVolume")]
662 pub live_volume: i64,
663 #[serde(rename = "totalVolume")]
664 pub total_volume: i64,
665 #[serde(rename = "pendingVolume")]
666 pub pending_volume: i64,
667 #[serde(rename = "liveInactiveVolume")]
668 pub live_inactive_volume: i64,
669}
670
671#[derive(Debug, Clone, Serialize)]
674pub struct CreateAccountRequest {
675 pub name: String,
676 #[serde(skip_serializing_if = "Option::is_none")]
677 pub description: Option<String>,
678 #[serde(rename = "iconUrl", skip_serializing_if = "Option::is_none")]
679 pub icon_url: Option<String>,
680 #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
681 pub provider_info: Option<serde_json::Value>,
682}
683
684#[derive(Debug, Clone, Serialize)]
685pub struct EditAccountRequest {
686 pub name: String,
687 #[serde(skip_serializing_if = "Option::is_none")]
688 pub description: Option<String>,
689 #[serde(rename = "iconUrl", skip_serializing_if = "Option::is_none")]
690 pub icon_url: Option<String>,
691 #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
692 pub provider_info: Option<serde_json::Value>,
693}
694
695#[derive(Debug, Clone, Serialize)]
696pub struct UpdateAccountQuotaRequest {
697 #[serde(rename = "quotaLimit")]
698 pub quota_limit: i64,
699 #[serde(rename = "quotaExcessPct", skip_serializing_if = "Option::is_none")]
700 pub quota_excess_pct: Option<i32>,
701}
702
703#[derive(Debug, Clone, Default)]
704pub struct AccountListOptions {
705 pub is_active: Option<bool>,
706 pub page: Option<i64>,
707 pub limit: Option<i64>,
708}
709
710#[derive(Debug, Clone, Serialize)]
713pub struct AddUserRequest {
714 #[serde(rename = "accountId")]
715 pub account_id: i64,
716 pub username: String,
717 pub email: String,
718 #[serde(skip_serializing_if = "Option::is_none")]
719 pub name: Option<String>,
720 #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
721 pub provider_info: Option<serde_json::Value>,
722}
723
724#[derive(Debug, Clone, Serialize)]
725pub struct BulkUserRequest {
726 pub ids: Vec<i64>,
727}
728
729#[derive(Debug, Clone, Serialize, Deserialize)]
730pub struct BulkUserResponse {
731 pub users: Vec<UserLite>,
732}
733
734#[derive(Debug, Clone, Serialize)]
735pub struct EditUserRequest {
736 pub username: String,
737 pub email: String,
738 #[serde(skip_serializing_if = "Option::is_none")]
739 pub name: Option<String>,
740 #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
741 pub provider_info: Option<serde_json::Value>,
742}
743
744#[derive(Debug, Clone, Default)]
745pub struct UserListOptions {
746 pub account_id: i64,
747 pub search: Option<String>,
748 pub is_active: Option<bool>,
749 pub page: Option<i64>,
750 pub limit: Option<i64>,
751}
752
753#[derive(Debug, Clone, Serialize)]
756pub struct CreateRegionRequest {
757 #[serde(rename = "accountId")]
758 pub account_id: i64,
759 pub name: String,
760 pub dns: String,
761}
762
763#[derive(Debug, Clone, Serialize)]
764pub struct EditRegionRequest {
765 #[serde(rename = "accountId")]
766 pub account_id: i64,
767 pub name: String,
768 pub dns: String,
769}
770
771#[derive(Debug, Clone, Default)]
772pub struct RegionListOptions {
773 pub is_active: Option<bool>,
774 pub page: Option<i64>,
775 pub limit: Option<i64>,
776}
777
778#[derive(Debug, Clone, Serialize)]
781pub struct CreateRegionClusterRequest {
782 pub name: String,
783}
784
785#[derive(Debug, Clone, Serialize)]
786pub struct EditRegionClusterRequest {
787 pub name: String,
788}
789
790#[derive(Debug, Clone, Serialize)]
791pub struct SetRegionClusterReadyRequest {
792 pub ready: bool,
793}
794
795#[derive(Debug, Clone, Serialize, Deserialize)]
796pub struct SetReadyRegionClusterResponse {
797 pub id: i64,
798 pub ready: bool,
799}
800
801#[derive(Debug, Clone, Default)]
802pub struct RegionClusterListOptions {
803 pub is_active: Option<bool>,
804 pub page: Option<i64>,
805 pub limit: Option<i64>,
806}
807
808#[derive(Debug, Clone, Serialize)]
811pub struct CreateStorageRequest {
812 #[serde(rename = "accountId")]
813 pub account_id: i64,
814 #[serde(rename = "regionId")]
815 pub region_id: i64,
816 pub name: String,
817 #[serde(skip_serializing_if = "Option::is_none")]
818 pub description: Option<String>,
819 #[serde(rename = "storageType")]
820 pub storage_type: String,
821 #[serde(rename = "providerType")]
822 pub provider_type: String,
823 pub endpoint: String,
824 #[serde(skip_serializing_if = "Option::is_none")]
825 pub region: Option<String>,
826 #[serde(skip_serializing_if = "Option::is_none")]
827 pub bucket: Option<String>,
828 #[serde(skip_serializing_if = "Option::is_none")]
829 pub base: Option<String>,
830 #[serde(rename = "blockRegion", skip_serializing_if = "Option::is_none")]
831 pub block_region: Option<String>,
832 #[serde(rename = "blockType", skip_serializing_if = "Option::is_none")]
833 pub block_type: Option<String>,
834 #[serde(rename = "blockSize", skip_serializing_if = "Option::is_none")]
835 pub block_size: Option<i32>,
836 #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none")]
837 pub access_key: Option<String>,
838 #[serde(rename = "secretKey", skip_serializing_if = "Option::is_none")]
839 pub secret_key: Option<String>,
840}
841
842#[derive(Debug, Clone, Serialize)]
843pub struct EditStorageRequest {
844 pub name: String,
845 #[serde(skip_serializing_if = "Option::is_none")]
846 pub description: Option<String>,
847 #[serde(skip_serializing_if = "Option::is_none")]
848 pub endpoint: Option<String>,
849 #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none")]
850 pub access_key: Option<String>,
851 #[serde(rename = "secretKey", skip_serializing_if = "Option::is_none")]
852 pub secret_key: Option<String>,
853}
854
855#[derive(Debug, Clone, Serialize)]
856pub struct TestStorageBucketRequest {
857 pub endpoint: String,
858 #[serde(skip_serializing_if = "Option::is_none")]
859 pub region: Option<String>,
860 pub bucket: String,
861 #[serde(rename = "accessKey")]
862 pub access_key: String,
863 #[serde(rename = "secretKey")]
864 pub secret_key: String,
865 #[serde(rename = "providerType", skip_serializing_if = "Option::is_none")]
866 pub provider_type: Option<String>,
867}
868
869#[derive(Debug, Clone, Serialize, Deserialize)]
870pub struct TestBucketStorageResponse {
871 #[serde(rename = "bucketExists")]
872 pub bucket_exists: bool,
873 pub list: bool,
874 pub write: bool,
875 pub read: bool,
876 pub delete: bool,
877 pub multipart: bool,
878}
879
880#[derive(Debug, Clone, Serialize, Deserialize)]
881pub struct TestStorageBucketStorageResponse {
882 #[serde(rename = "bucketExists")]
883 pub bucket_exists: bool,
884 pub list: bool,
885 pub write: bool,
886 pub read: bool,
887 pub delete: bool,
888 pub multipart: bool,
889}
890
891#[derive(Debug, Clone, Default)]
892pub struct StorageListOptions {
893 pub account_id: i64,
894 pub search: Option<String>,
895 pub region_id: Option<i64>,
896 pub storage_type: Option<String>,
897 pub provider_type: Option<String>,
898 pub is_active: Option<bool>,
899 pub page: Option<i64>,
900 pub limit: Option<i64>,
901}
902
903#[derive(Debug, Clone, Serialize)]
906pub struct CreateVolumeRequest {
907 #[serde(rename = "accountId")]
908 pub account_id: i64,
909 #[serde(rename = "storageId")]
910 pub storage_id: i64,
911 pub name: String,
912 #[serde(skip_serializing_if = "Option::is_none")]
913 pub description: Option<String>,
914 #[serde(rename = "volumeType")]
915 pub volume_type: String,
916 #[serde(skip_serializing_if = "Option::is_none")]
917 pub encryption: Option<bool>,
918 #[serde(rename = "encryptionKey", skip_serializing_if = "Option::is_none")]
919 pub encryption_key: Option<String>,
920 #[serde(rename = "retentionPeriod", skip_serializing_if = "Option::is_none")]
921 pub retention_period: Option<i32>,
922 #[serde(rename = "gracePeriod", skip_serializing_if = "Option::is_none")]
923 pub grace_period: Option<i32>,
924 #[serde(rename = "forkGracePeriod", skip_serializing_if = "Option::is_none")]
925 pub fork_grace_period: Option<i32>,
926 #[serde(rename = "eventLogRetentionPeriod", skip_serializing_if = "Option::is_none")]
927 pub event_log_retention_period: Option<i32>,
928 #[serde(rename = "quotaLimit", skip_serializing_if = "Option::is_none")]
929 pub quota_limit: Option<i64>,
930 #[serde(rename = "regionClusterId", skip_serializing_if = "Option::is_none")]
931 pub region_cluster_id: Option<i64>,
932 #[serde(rename = "regionClusterUuid", skip_serializing_if = "Option::is_none")]
933 pub region_cluster_uuid: Option<String>,
934}
935
936#[derive(Debug, Clone, Serialize, Deserialize)]
937pub struct CreateVolumeResponse {
938 pub id: i64,
939 #[serde(rename = "encryptionKey", skip_serializing_if = "Option::is_none")]
940 pub encryption_key: Option<String>,
941}
942
943#[derive(Debug, Clone, Serialize)]
944pub struct EditVolumeRequest {
945 #[serde(skip_serializing_if = "Option::is_none")]
946 pub description: Option<String>,
947 #[serde(rename = "retentionPeriod", skip_serializing_if = "Option::is_none")]
948 pub retention_period: Option<i32>,
949 #[serde(rename = "gracePeriod", skip_serializing_if = "Option::is_none")]
950 pub grace_period: Option<i32>,
951 #[serde(rename = "forkGracePeriod", skip_serializing_if = "Option::is_none")]
952 pub fork_grace_period: Option<i32>,
953 #[serde(rename = "eventLogRetentionPeriod", skip_serializing_if = "Option::is_none")]
954 pub event_log_retention_period: Option<i32>,
955}
956
957#[derive(Debug, Clone, Serialize)]
958pub struct MoveVolumeClusterRequest {
959 #[serde(rename = "targetClusterId", skip_serializing_if = "Option::is_none")]
960 pub target_cluster_id: Option<i64>,
961 #[serde(rename = "targetClusterUuid", skip_serializing_if = "Option::is_none")]
962 pub target_cluster_uuid: Option<String>,
963}
964
965#[derive(Debug, Clone, Serialize, Deserialize)]
966pub struct MoveClusterVolumeResponse {
967 pub id: i64,
968 #[serde(rename = "sourceClusterId")]
969 pub source_cluster_id: i64,
970 #[serde(rename = "targetClusterId")]
971 pub target_cluster_id: i64,
972 #[serde(rename = "handoverUntil")]
973 pub handover_until: i64,
974}
975
976#[derive(Debug, Clone, Serialize)]
977pub struct DeactivateVolumeRequest {
978 #[serde(rename = "isCleanupMetaEnabled", skip_serializing_if = "Option::is_none")]
979 pub is_cleanup_meta_enabled: Option<bool>,
980 #[serde(rename = "isCleanupStorageEnabled", skip_serializing_if = "Option::is_none")]
981 pub is_cleanup_storage_enabled: Option<bool>,
982 #[serde(rename = "isCleanupVaultEnabled", skip_serializing_if = "Option::is_none")]
983 pub is_cleanup_vault_enabled: Option<bool>,
984}
985
986#[derive(Debug, Clone, Serialize)]
987pub struct GenerateVolumeAPIKeysRequest {
988 #[serde(rename = "userId")]
989 pub user_id: i64,
990}
991
992#[derive(Debug, Clone, Serialize, Deserialize)]
993pub struct GenerateAPIKeysVolumeResponse {
994 #[serde(rename = "apiKey")]
995 pub api_key: String,
996 #[serde(rename = "apiSecret")]
997 pub api_secret: String,
998}
999
1000#[derive(Debug, Clone, Serialize)]
1001pub struct RevokeVolumeAPIKeyRequest {
1002 #[serde(rename = "apiKey")]
1003 pub api_key: String,
1004}
1005
1006#[derive(Debug, Clone, Serialize)]
1007pub struct RevokeVolumeAPIKeysByUserRequest {
1008 #[serde(rename = "userId")]
1009 pub user_id: i64,
1010}
1011
1012#[derive(Debug, Clone, Serialize)]
1013pub struct UpdateVolumeQuotaRequest {
1014 #[serde(rename = "quotaLimit")]
1015 pub quota_limit: i64,
1016}
1017
1018#[derive(Debug, Clone, Serialize, Deserialize)]
1019pub struct StatsVolumeResponse {
1020 #[serde(rename = "volumeId")]
1021 pub volume_id: String,
1022 #[serde(rename = "liveVolume")]
1023 pub live_volume: i64,
1024 #[serde(rename = "totalVolume")]
1025 pub total_volume: i64,
1026 #[serde(rename = "pendingVolume")]
1027 pub pending_volume: i64,
1028 #[serde(rename = "liveInactiveVolume")]
1029 pub live_inactive_volume: i64,
1030}
1031
1032#[derive(Debug, Clone, Serialize, Deserialize)]
1033pub struct SizeHistoryVolumeResponse {
1034 pub points: Vec<VolumeSizePoint>,
1035}
1036
1037#[derive(Debug, Clone, Serialize)]
1038pub struct CreateVolumeForkRequest {
1039 pub name: String,
1040 #[serde(rename = "parentName", skip_serializing_if = "Option::is_none")]
1041 pub parent_name: Option<String>,
1042 #[serde(rename = "asOf", skip_serializing_if = "Option::is_none")]
1043 pub as_of: Option<i64>,
1044 #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1045 pub volume_type: Option<String>,
1046}
1047
1048#[derive(Debug, Clone, Serialize)]
1049pub struct DeleteVolumeForkRequest {
1050 #[serde(skip_serializing_if = "Option::is_none")]
1051 pub force: Option<bool>,
1052 #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1053 pub volume_type: Option<String>,
1054}
1055
1056#[derive(Debug, Clone, Serialize, Deserialize)]
1057pub struct DeleteForkVolumeResponse {
1058 #[serde(rename = "inactivatedFids")]
1059 pub inactivated_fids: Vec<i32>,
1060}
1061
1062#[derive(Debug, Clone, Serialize)]
1063pub struct RestoreVolumeForkRequest {
1064 #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1065 pub volume_type: Option<String>,
1066}
1067
1068#[derive(Debug, Clone, Default)]
1069pub struct VolumeListOptions {
1070 pub account_id: i64,
1071 pub region_id: Option<i64>,
1072 pub region_cluster_id: Option<i64>,
1073 pub storage_id: Option<i64>,
1074 pub volume_type: Option<String>,
1075 pub locked: Option<bool>,
1076 pub is_active: Option<bool>,
1077 pub page: Option<i64>,
1078 pub limit: Option<i64>,
1079}
1080
1081#[derive(Debug, Clone, Default)]
1084pub struct VolumeForkTreeListOptions {
1085 pub path: Option<String>,
1086 pub as_of: Option<i64>,
1087 pub cursor: Option<i64>,
1088 pub limit: Option<i64>,
1089 pub sort: Option<String>,
1090 pub kind: Option<String>,
1091}
1092
1093#[derive(Debug, Clone, Default)]
1096pub struct VolumeForkEntryListOptions {
1097 pub path: Option<String>,
1098 pub cursor: Option<i64>,
1099 pub limit: Option<i64>,
1100}
1101
1102#[derive(Debug, Clone, Default)]
1105pub struct VolumeForkSearchListOptions {
1106 pub q: Option<String>,
1107 pub path: Option<String>,
1108 pub as_of: Option<i64>,
1109 pub exact: Option<bool>,
1110 pub cursor: Option<i64>,
1111 pub limit: Option<i64>,
1112 pub kind: Option<String>,
1113}
1114
1115#[derive(Debug, Clone, Default)]
1118pub struct AuditLogListOptions {
1119 pub account_id: Option<i64>,
1120 pub region_id: Option<i64>,
1121 pub region_cluster_id: Option<i64>,
1122 pub cursor: Option<i64>,
1123 pub limit: Option<i64>,
1124 pub subject: Option<String>,
1125}
1126
1127#[derive(Debug, Clone, Default)]
1130pub struct RegionAuditLogListOptions {
1131 pub region_cluster_id: Option<i64>,
1132 pub cursor: Option<i64>,
1133 pub limit: Option<i64>,
1134 pub subject: Option<String>,
1135 pub node: Option<String>,
1136}
1137
1138#[derive(Debug, Clone, Default)]
1145pub struct ClientSessionListOptions {
1146 pub account_id: Option<i64>,
1147 pub region_id: Option<i64>,
1148 pub region_cluster_id: Option<i64>,
1149 pub volume_id: Option<i64>,
1150 pub user_id: Option<i64>,
1151 pub client_type: Option<String>,
1152 pub status: Option<ClientSessionStatus>,
1153 pub is_active: Option<String>,
1154 pub os_name: Option<String>,
1155 pub platform: Option<String>,
1156 pub search: Option<String>,
1157 pub page: Option<i64>,
1158 pub limit: Option<i64>,
1159}
1160
1161#[derive(Debug, Clone, Default)]
1170pub struct AlertListOptions {
1171 pub active: Option<bool>,
1172 pub account_id: Option<i64>,
1173 pub region_id: Option<i64>,
1174 pub severity: Option<i64>,
1175 pub category: Option<String>,
1176 pub since: Option<String>,
1177 pub page: Option<i64>,
1178 pub limit: Option<i64>,
1179}
1180
1181#[derive(Debug, Clone, Default)]
1184pub struct RegionAlertListOptions {
1185 pub active: Option<bool>,
1186 pub severity: Option<i64>,
1187 pub category: Option<String>,
1188 pub node_id: Option<String>,
1189 pub region_cluster_id: Option<i64>,
1190 pub since: Option<String>,
1191 pub page: Option<i64>,
1192 pub limit: Option<i64>,
1193}
1194
1195