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