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<String>,
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: Ref,
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 VolumeSizePoint {
651 #[serde(rename = "bucketEnd")]
652 pub bucket_end: String,
653 #[serde(rename = "liveVolume")]
654 pub live_volume: i64,
655 #[serde(rename = "totalVolume")]
656 pub total_volume: i64,
657 #[serde(rename = "pendingVolume")]
658 pub pending_volume: i64,
659 #[serde(rename = "liveInactiveVolume")]
660 pub live_inactive_volume: i64,
661}
662
663#[derive(Debug, Clone, Serialize)]
666pub struct CreateAccountRequest {
667 pub name: String,
668 #[serde(skip_serializing_if = "Option::is_none")]
669 pub description: Option<String>,
670 #[serde(rename = "iconUrl", skip_serializing_if = "Option::is_none")]
671 pub icon_url: Option<String>,
672 #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
673 pub provider_info: Option<serde_json::Value>,
674}
675
676#[derive(Debug, Clone, Serialize)]
677pub struct EditAccountRequest {
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 UpdateAccountQuotaRequest {
689 #[serde(rename = "quotaLimit")]
690 pub quota_limit: i64,
691 #[serde(rename = "quotaExcessPct", skip_serializing_if = "Option::is_none")]
692 pub quota_excess_pct: Option<i32>,
693}
694
695#[derive(Debug, Clone, Default)]
696pub struct AccountListOptions {
697 pub is_active: Option<bool>,
698 pub page: Option<i64>,
699 pub limit: Option<i64>,
700}
701
702#[derive(Debug, Clone, Serialize)]
705pub struct AddUserRequest {
706 #[serde(rename = "accountId")]
707 pub account_id: i64,
708 pub username: String,
709 pub email: String,
710 #[serde(skip_serializing_if = "Option::is_none")]
711 pub name: Option<String>,
712 #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
713 pub provider_info: Option<serde_json::Value>,
714}
715
716#[derive(Debug, Clone, Serialize)]
717pub struct BulkUserRequest {
718 pub ids: Vec<i64>,
719}
720
721#[derive(Debug, Clone, Serialize, Deserialize)]
722pub struct BulkUserResponse {
723 pub users: Vec<UserLite>,
724}
725
726#[derive(Debug, Clone, Serialize)]
727pub struct EditUserRequest {
728 pub username: String,
729 pub email: String,
730 #[serde(skip_serializing_if = "Option::is_none")]
731 pub name: Option<String>,
732 #[serde(rename = "providerInfo", skip_serializing_if = "Option::is_none")]
733 pub provider_info: Option<serde_json::Value>,
734}
735
736#[derive(Debug, Clone, Default)]
737pub struct UserListOptions {
738 pub account_id: i64,
739 pub search: Option<String>,
740 pub is_active: Option<bool>,
741 pub page: Option<i64>,
742 pub limit: Option<i64>,
743}
744
745#[derive(Debug, Clone, Serialize)]
748pub struct CreateRegionRequest {
749 #[serde(rename = "accountId")]
750 pub account_id: i64,
751 pub name: String,
752 pub dns: String,
753}
754
755#[derive(Debug, Clone, Serialize)]
756pub struct EditRegionRequest {
757 #[serde(rename = "accountId")]
758 pub account_id: i64,
759 pub name: String,
760 pub dns: String,
761}
762
763#[derive(Debug, Clone, Default)]
764pub struct RegionListOptions {
765 pub is_active: Option<bool>,
766 pub page: Option<i64>,
767 pub limit: Option<i64>,
768}
769
770#[derive(Debug, Clone, Serialize)]
773pub struct CreateRegionClusterRequest {
774 pub name: String,
775}
776
777#[derive(Debug, Clone, Serialize)]
778pub struct EditRegionClusterRequest {
779 pub name: String,
780}
781
782#[derive(Debug, Clone, Serialize)]
783pub struct SetRegionClusterReadyRequest {
784 pub ready: bool,
785}
786
787#[derive(Debug, Clone, Serialize, Deserialize)]
788pub struct SetReadyRegionClusterResponse {
789 pub id: i64,
790 pub ready: bool,
791}
792
793#[derive(Debug, Clone, Default)]
794pub struct RegionClusterListOptions {
795 pub is_active: Option<bool>,
796 pub page: Option<i64>,
797 pub limit: Option<i64>,
798}
799
800#[derive(Debug, Clone, Serialize)]
803pub struct CreateStorageRequest {
804 #[serde(rename = "accountId")]
805 pub account_id: i64,
806 #[serde(rename = "regionId")]
807 pub region_id: i64,
808 pub name: String,
809 #[serde(skip_serializing_if = "Option::is_none")]
810 pub description: Option<String>,
811 #[serde(rename = "storageType")]
812 pub storage_type: String,
813 #[serde(rename = "providerType")]
814 pub provider_type: String,
815 pub endpoint: String,
816 #[serde(skip_serializing_if = "Option::is_none")]
817 pub region: Option<String>,
818 #[serde(skip_serializing_if = "Option::is_none")]
819 pub bucket: Option<String>,
820 #[serde(skip_serializing_if = "Option::is_none")]
821 pub base: Option<String>,
822 #[serde(rename = "blockRegion", skip_serializing_if = "Option::is_none")]
823 pub block_region: Option<String>,
824 #[serde(rename = "blockType", skip_serializing_if = "Option::is_none")]
825 pub block_type: Option<String>,
826 #[serde(rename = "blockSize", skip_serializing_if = "Option::is_none")]
827 pub block_size: Option<i32>,
828 #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none")]
829 pub access_key: Option<String>,
830 #[serde(rename = "secretKey", skip_serializing_if = "Option::is_none")]
831 pub secret_key: Option<String>,
832}
833
834#[derive(Debug, Clone, Serialize)]
835pub struct EditStorageRequest {
836 pub name: String,
837 #[serde(skip_serializing_if = "Option::is_none")]
838 pub description: Option<String>,
839 #[serde(skip_serializing_if = "Option::is_none")]
840 pub endpoint: Option<String>,
841 #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none")]
842 pub access_key: Option<String>,
843 #[serde(rename = "secretKey", skip_serializing_if = "Option::is_none")]
844 pub secret_key: Option<String>,
845}
846
847#[derive(Debug, Clone, Serialize)]
848pub struct TestStorageBucketRequest {
849 pub endpoint: String,
850 #[serde(skip_serializing_if = "Option::is_none")]
851 pub region: Option<String>,
852 pub bucket: String,
853 #[serde(rename = "accessKey")]
854 pub access_key: String,
855 #[serde(rename = "secretKey")]
856 pub secret_key: String,
857 #[serde(rename = "providerType", skip_serializing_if = "Option::is_none")]
858 pub provider_type: Option<String>,
859}
860
861#[derive(Debug, Clone, Serialize, Deserialize)]
862pub struct TestBucketStorageResponse {
863 #[serde(rename = "bucketExists")]
864 pub bucket_exists: bool,
865 pub list: bool,
866 pub write: bool,
867 pub read: bool,
868 pub delete: bool,
869 pub multipart: bool,
870}
871
872#[derive(Debug, Clone, Serialize, Deserialize)]
873pub struct TestStorageBucketStorageResponse {
874 #[serde(rename = "bucketExists")]
875 pub bucket_exists: bool,
876 pub list: bool,
877 pub write: bool,
878 pub read: bool,
879 pub delete: bool,
880 pub multipart: bool,
881}
882
883#[derive(Debug, Clone, Default)]
884pub struct StorageListOptions {
885 pub account_id: i64,
886 pub search: Option<String>,
887 pub region_id: Option<i64>,
888 pub storage_type: Option<String>,
889 pub provider_type: Option<String>,
890 pub is_active: Option<bool>,
891 pub page: Option<i64>,
892 pub limit: Option<i64>,
893}
894
895#[derive(Debug, Clone, Serialize)]
898pub struct CreateVolumeRequest {
899 #[serde(rename = "accountId")]
900 pub account_id: i64,
901 #[serde(rename = "storageId")]
902 pub storage_id: i64,
903 pub name: String,
904 #[serde(skip_serializing_if = "Option::is_none")]
905 pub description: Option<String>,
906 #[serde(rename = "volumeType")]
907 pub volume_type: String,
908 #[serde(skip_serializing_if = "Option::is_none")]
909 pub encryption: Option<bool>,
910 #[serde(rename = "encryptionKey", skip_serializing_if = "Option::is_none")]
911 pub encryption_key: Option<String>,
912 #[serde(rename = "retentionPeriod", skip_serializing_if = "Option::is_none")]
913 pub retention_period: Option<i32>,
914 #[serde(rename = "gracePeriod", skip_serializing_if = "Option::is_none")]
915 pub grace_period: Option<i32>,
916 #[serde(rename = "forkGracePeriod", skip_serializing_if = "Option::is_none")]
917 pub fork_grace_period: Option<i32>,
918 #[serde(rename = "eventLogRetentionPeriod", skip_serializing_if = "Option::is_none")]
919 pub event_log_retention_period: Option<i32>,
920 #[serde(rename = "quotaLimit", skip_serializing_if = "Option::is_none")]
921 pub quota_limit: Option<i64>,
922 #[serde(rename = "regionClusterId", skip_serializing_if = "Option::is_none")]
923 pub region_cluster_id: Option<i64>,
924 #[serde(rename = "regionClusterUuid", skip_serializing_if = "Option::is_none")]
925 pub region_cluster_uuid: Option<String>,
926}
927
928#[derive(Debug, Clone, Serialize, Deserialize)]
929pub struct CreateVolumeResponse {
930 pub id: i64,
931 #[serde(rename = "encryptionKey", skip_serializing_if = "Option::is_none")]
932 pub encryption_key: Option<String>,
933}
934
935#[derive(Debug, Clone, Serialize)]
936pub struct EditVolumeRequest {
937 #[serde(skip_serializing_if = "Option::is_none")]
938 pub description: Option<String>,
939 #[serde(rename = "retentionPeriod", skip_serializing_if = "Option::is_none")]
940 pub retention_period: Option<i32>,
941 #[serde(rename = "gracePeriod", skip_serializing_if = "Option::is_none")]
942 pub grace_period: Option<i32>,
943 #[serde(rename = "forkGracePeriod", skip_serializing_if = "Option::is_none")]
944 pub fork_grace_period: Option<i32>,
945 #[serde(rename = "eventLogRetentionPeriod", skip_serializing_if = "Option::is_none")]
946 pub event_log_retention_period: Option<i32>,
947}
948
949#[derive(Debug, Clone, Serialize)]
950pub struct MoveVolumeClusterRequest {
951 #[serde(rename = "targetClusterId", skip_serializing_if = "Option::is_none")]
952 pub target_cluster_id: Option<i64>,
953 #[serde(rename = "targetClusterUuid", skip_serializing_if = "Option::is_none")]
954 pub target_cluster_uuid: Option<String>,
955}
956
957#[derive(Debug, Clone, Serialize, Deserialize)]
958pub struct MoveClusterVolumeResponse {
959 pub id: i64,
960 #[serde(rename = "sourceClusterId")]
961 pub source_cluster_id: i64,
962 #[serde(rename = "targetClusterId")]
963 pub target_cluster_id: i64,
964 #[serde(rename = "handoverUntil")]
965 pub handover_until: i64,
966}
967
968#[derive(Debug, Clone, Serialize)]
969pub struct DeactivateVolumeRequest {
970 #[serde(rename = "isCleanupMetaEnabled", skip_serializing_if = "Option::is_none")]
971 pub is_cleanup_meta_enabled: Option<bool>,
972 #[serde(rename = "isCleanupStorageEnabled", skip_serializing_if = "Option::is_none")]
973 pub is_cleanup_storage_enabled: Option<bool>,
974 #[serde(rename = "isCleanupVaultEnabled", skip_serializing_if = "Option::is_none")]
975 pub is_cleanup_vault_enabled: Option<bool>,
976}
977
978#[derive(Debug, Clone, Serialize)]
979pub struct GenerateVolumeAPIKeysRequest {
980 #[serde(rename = "userId")]
981 pub user_id: i64,
982}
983
984#[derive(Debug, Clone, Serialize, Deserialize)]
985pub struct GenerateAPIKeysVolumeResponse {
986 #[serde(rename = "apiKey")]
987 pub api_key: String,
988 #[serde(rename = "apiSecret")]
989 pub api_secret: String,
990}
991
992#[derive(Debug, Clone, Serialize)]
993pub struct RevokeVolumeAPIKeyRequest {
994 #[serde(rename = "apiKey")]
995 pub api_key: String,
996}
997
998#[derive(Debug, Clone, Serialize)]
999pub struct RevokeVolumeAPIKeysByUserRequest {
1000 #[serde(rename = "userId")]
1001 pub user_id: i64,
1002}
1003
1004#[derive(Debug, Clone, Serialize)]
1005pub struct UpdateVolumeQuotaRequest {
1006 #[serde(rename = "quotaLimit")]
1007 pub quota_limit: i64,
1008}
1009
1010#[derive(Debug, Clone, Serialize, Deserialize)]
1011pub struct StatsVolumeResponse {
1012 #[serde(rename = "volumeId")]
1013 pub volume_id: String,
1014 #[serde(rename = "liveVolume")]
1015 pub live_volume: i64,
1016 #[serde(rename = "totalVolume")]
1017 pub total_volume: i64,
1018 #[serde(rename = "pendingVolume")]
1019 pub pending_volume: i64,
1020 #[serde(rename = "liveInactiveVolume")]
1021 pub live_inactive_volume: i64,
1022}
1023
1024#[derive(Debug, Clone, Serialize, Deserialize)]
1025pub struct SizeHistoryVolumeResponse {
1026 pub points: Vec<VolumeSizePoint>,
1027}
1028
1029#[derive(Debug, Clone, Serialize)]
1030pub struct CreateVolumeForkRequest {
1031 pub name: String,
1032 #[serde(rename = "parentName", skip_serializing_if = "Option::is_none")]
1033 pub parent_name: Option<String>,
1034 #[serde(rename = "asOf", skip_serializing_if = "Option::is_none")]
1035 pub as_of: Option<i64>,
1036 #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1037 pub volume_type: Option<String>,
1038}
1039
1040#[derive(Debug, Clone, Serialize)]
1041pub struct DeleteVolumeForkRequest {
1042 #[serde(skip_serializing_if = "Option::is_none")]
1043 pub force: Option<bool>,
1044 #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1045 pub volume_type: Option<String>,
1046}
1047
1048#[derive(Debug, Clone, Serialize, Deserialize)]
1049pub struct DeleteForkVolumeResponse {
1050 #[serde(rename = "inactivatedFids")]
1051 pub inactivated_fids: Vec<i32>,
1052}
1053
1054#[derive(Debug, Clone, Serialize)]
1055pub struct RestoreVolumeForkRequest {
1056 #[serde(rename = "volumeType", skip_serializing_if = "Option::is_none")]
1057 pub volume_type: Option<String>,
1058}
1059
1060#[derive(Debug, Clone, Default)]
1061pub struct VolumeListOptions {
1062 pub account_id: i64,
1063 pub region_id: Option<i64>,
1064 pub region_cluster_id: Option<i64>,
1065 pub storage_id: Option<i64>,
1066 pub volume_type: Option<String>,
1067 pub locked: Option<bool>,
1068 pub is_active: Option<bool>,
1069 pub page: Option<i64>,
1070 pub limit: Option<i64>,
1071}
1072
1073#[derive(Debug, Clone, Default)]
1076pub struct VolumeForkTreeListOptions {
1077 pub path: Option<String>,
1078 pub as_of: Option<i64>,
1079 pub cursor: Option<i64>,
1080 pub limit: Option<i64>,
1081 pub sort: Option<String>,
1082 pub kind: Option<String>,
1083}
1084
1085#[derive(Debug, Clone, Default)]
1088pub struct VolumeForkEntryListOptions {
1089 pub path: Option<String>,
1090 pub cursor: Option<i64>,
1091 pub limit: Option<i64>,
1092}
1093
1094#[derive(Debug, Clone, Default)]
1097pub struct VolumeForkSearchListOptions {
1098 pub q: Option<String>,
1099 pub path: Option<String>,
1100 pub as_of: Option<i64>,
1101 pub exact: Option<bool>,
1102 pub cursor: Option<i64>,
1103 pub limit: Option<i64>,
1104 pub kind: Option<String>,
1105}
1106
1107#[derive(Debug, Clone, Default)]
1110pub struct AuditLogListOptions {
1111 pub account_id: Option<i64>,
1112 pub region_id: Option<i64>,
1113 pub region_cluster_id: Option<i64>,
1114 pub cursor: Option<i64>,
1115 pub limit: Option<i64>,
1116 pub subject: Option<String>,
1117}
1118
1119#[derive(Debug, Clone, Default)]
1122pub struct RegionAuditLogListOptions {
1123 pub region_cluster_id: Option<i64>,
1124 pub cursor: Option<i64>,
1125 pub limit: Option<i64>,
1126 pub subject: Option<String>,
1127 pub node: Option<String>,
1128}
1129
1130#[derive(Debug, Clone, Default)]
1137pub struct ClientSessionListOptions {
1138 pub account_id: Option<i64>,
1139 pub region_id: Option<i64>,
1140 pub region_cluster_id: Option<i64>,
1141 pub volume_id: Option<i64>,
1142 pub user_id: Option<i64>,
1143 pub client_type: Option<String>,
1144 pub status: Option<ClientSessionStatus>,
1145 pub is_active: Option<String>,
1146 pub os_name: Option<String>,
1147 pub platform: Option<String>,
1148 pub search: Option<String>,
1149 pub page: Option<i64>,
1150 pub limit: Option<i64>,
1151}
1152
1153#[derive(Debug, Clone, Default)]
1162pub struct AlertListOptions {
1163 pub active: Option<bool>,
1164 pub account_id: Option<i64>,
1165 pub region_id: Option<i64>,
1166 pub severity: Option<i64>,
1167 pub category: Option<String>,
1168 pub since: Option<String>,
1169 pub page: Option<i64>,
1170 pub limit: Option<i64>,
1171}
1172
1173#[derive(Debug, Clone, Default)]
1176pub struct RegionAlertListOptions {
1177 pub active: Option<bool>,
1178 pub severity: Option<i64>,
1179 pub category: Option<String>,
1180 pub node_id: Option<String>,
1181 pub region_cluster_id: Option<i64>,
1182 pub since: Option<String>,
1183 pub page: Option<i64>,
1184 pub limit: Option<i64>,
1185}
1186
1187