hivehub_internal_sdk/
models.rs

1use chrono::{DateTime, Utc};
2use serde::{Deserialize, Serialize};
3use uuid::Uuid;
4
5/// User information response
6#[derive(Debug, Clone, Serialize, Deserialize)]
7pub struct UserInfo {
8    pub id: Uuid,
9    pub email: String,
10    pub plan: String,
11    pub created_at: DateTime<Utc>,
12}
13
14/// Quota check request
15#[derive(Debug, Clone, Serialize)]
16pub struct QuotaCheckRequest {
17    pub project_id: String,
18    pub operation: String,
19    #[serde(skip_serializing_if = "Option::is_none")]
20    pub estimated_size: Option<i64>,
21}
22
23/// Quota check response
24#[derive(Debug, Clone, Serialize, Deserialize)]
25pub struct QuotaCheckResponse {
26    pub allowed: bool,
27    #[serde(default)]
28    pub remaining: Option<i64>,
29    #[serde(default)]
30    pub limit: Option<i64>,
31}
32
33/// Generic error response from API
34#[derive(Debug, Clone, Deserialize)]
35pub struct ErrorResponse {
36    pub error: String,
37    #[serde(default)]
38    pub details: Option<String>,
39}
40
41// Vectorizer Models
42
43/// Collection information
44#[derive(Debug, Clone, Serialize, Deserialize)]
45pub struct Collection {
46    pub collection_id: Uuid,
47    pub collection_name: String,
48    pub project_id: Uuid,
49    pub project_name: String,
50    pub vector_count: u64,
51    pub dimension: u32,
52    pub created_at: DateTime<Utc>,
53}
54
55/// User collections response
56#[derive(Debug, Clone, Serialize, Deserialize)]
57pub struct UserCollectionsResponse {
58    pub user_id: Uuid,
59    pub collections: Vec<Collection>,
60    pub total_collections: u32,
61    pub plan: String,
62    pub collection_limit: u32,
63}
64
65/// Quota information
66#[derive(Debug, Clone, Serialize, Deserialize)]
67pub struct Quota {
68    pub max_vectors: u64,
69    pub current_vectors: u64,
70    pub can_insert: bool,
71}
72
73/// Collection validation response
74#[derive(Debug, Clone, Serialize, Deserialize)]
75pub struct CollectionValidation {
76    pub valid: bool,
77    pub user_id: Uuid,
78    pub collection_id: Uuid,
79    pub quota: Quota,
80    pub plan: String,
81}
82
83/// Create collection request
84#[derive(Debug, Clone, Serialize)]
85pub struct CreateCollectionRequest {
86    pub collection_name: String,
87    pub project_id: Uuid,
88    pub dimension: u32,
89}
90
91/// Create collection response
92#[derive(Debug, Clone, Serialize, Deserialize)]
93pub struct CreateCollectionResponse {
94    pub collection_id: Uuid,
95    pub collection_name: String,
96    pub created: bool,
97}
98
99/// Update usage request
100#[derive(Debug, Clone, Serialize)]
101pub struct UpdateUsageRequest {
102    pub vector_count: u64,
103    pub storage_bytes: u64,
104}
105
106/// Update usage response
107#[derive(Debug, Clone, Serialize, Deserialize)]
108pub struct UpdateUsageResponse {
109    pub success: bool,
110    pub updated: bool,
111    pub quota: Quota,
112}
113
114// Nexus Models
115
116/// Database information
117#[derive(Debug, Clone, Serialize, Deserialize)]
118pub struct DatabaseInfo {
119    pub database_name: String,
120    pub quota: NexusQuota,
121    pub credits: Credits,
122}
123
124/// Nexus quota information
125#[derive(Debug, Clone, Serialize, Deserialize)]
126pub struct NexusQuota {
127    pub max_nodes: u64,
128    pub current_nodes: u64,
129    pub max_relationships: u64,
130    pub current_relationships: u64,
131    pub storage_limit_mb: u64,
132    pub storage_used_mb: u64,
133}
134
135/// Credits information
136#[derive(Debug, Clone, Serialize, Deserialize)]
137pub struct Credits {
138    pub available: u64,
139    pub total: u64,
140    pub used: u64,
141}
142
143/// Consume credits request
144#[derive(Debug, Clone, Serialize)]
145pub struct ConsumeCreditsRequest {
146    pub amount: u64,
147    pub operation: String,
148    #[serde(skip_serializing_if = "Option::is_none")]
149    pub description: Option<String>,
150}
151
152/// Consume credits response
153#[derive(Debug, Clone, Serialize, Deserialize)]
154pub struct ConsumeCreditsResponse {
155    pub success: bool,
156    pub can_continue: bool,
157    pub credits_remaining: u64,
158}
159
160/// Nexus update usage request
161#[derive(Debug, Clone, Serialize)]
162pub struct NexusUpdateUsageRequest {
163    pub nodes_created: u64,
164    pub relationships_created: u64,
165    pub storage_bytes: u64,
166    pub credits_used: u64,
167}
168
169// Synap Models
170
171/// Resource type enumeration
172#[derive(Debug, Clone, Serialize, Deserialize)]
173#[serde(rename_all = "lowercase")]
174pub enum ResourceType {
175    Queue,
176    Stream,
177    KeyValue,
178}
179
180/// User resources response
181#[derive(Debug, Clone, Serialize, Deserialize)]
182pub struct UserResourcesResponse {
183    pub user_id: Uuid,
184    pub resources: Resources,
185}
186
187/// Resources information
188#[derive(Debug, Clone, Serialize, Deserialize)]
189pub struct Resources {
190    pub queues: Vec<String>,
191    pub streams: Vec<String>,
192    pub key_value_stores: Vec<String>,
193}
194
195/// Resource validation response
196#[derive(Debug, Clone, Serialize, Deserialize)]
197pub struct ResourceValidation {
198    pub belongs_to_user: bool,
199    pub resource_name: String,
200    pub resource_type: ResourceType,
201}
202
203/// Resource configuration
204#[derive(Debug, Clone, Serialize)]
205pub struct ResourceConfig {
206    #[serde(skip_serializing_if = "Option::is_none")]
207    pub max_size: Option<u64>,
208    #[serde(skip_serializing_if = "Option::is_none")]
209    pub ttl: Option<u64>,
210}
211
212/// Create resource request
213#[derive(Debug, Clone, Serialize)]
214pub struct CreateResourceRequest {
215    pub resource_type: ResourceType,
216    pub resource_name: String,
217    #[serde(skip_serializing_if = "Option::is_none")]
218    pub config: Option<ResourceConfig>,
219}
220
221/// Create resource response
222#[derive(Debug, Clone, Serialize, Deserialize)]
223pub struct CreateResourceResponse {
224    pub full_resource_name: String,
225    pub created: bool,
226}
227
228/// Synap update usage request
229#[derive(Debug, Clone, Serialize)]
230pub struct SynapUpdateUsageRequest {
231    pub resource_type: ResourceType,
232    pub resource_name: String,
233    #[serde(skip_serializing_if = "Option::is_none")]
234    pub message_count: Option<u64>,
235    #[serde(skip_serializing_if = "Option::is_none")]
236    pub storage_bytes: Option<u64>,
237}
238
239// LessTokens Models
240
241/// Token information
242#[derive(Debug, Clone, Serialize, Deserialize)]
243pub struct TokenInfo {
244    pub available: u64,
245    pub used: u64,
246    pub total: u64,
247    pub limit_reached: bool,
248}
249
250/// User tokens response
251#[derive(Debug, Clone, Serialize, Deserialize)]
252pub struct UserTokensResponse {
253    pub user_id: Uuid,
254    pub tokens: TokenInfo,
255}
256
257/// Token validation response
258#[derive(Debug, Clone, Serialize, Deserialize)]
259pub struct TokenValidation {
260    pub allowed: bool,
261    pub tokens_available: u64,
262    pub tokens_required: u64,
263}
264
265/// Consume tokens request
266#[derive(Debug, Clone, Serialize)]
267pub struct ConsumeTokensRequest {
268    pub amount: u64,
269    pub operation: String,
270    #[serde(skip_serializing_if = "Option::is_none")]
271    pub description: Option<String>,
272}
273
274/// Consume tokens response
275#[derive(Debug, Clone, Serialize, Deserialize)]
276pub struct ConsumeTokensResponse {
277    pub success: bool,
278    pub tokens_remaining: u64,
279}
280
281/// Limit check response
282#[derive(Debug, Clone, Serialize, Deserialize)]
283pub struct LimitCheckResponse {
284    pub tokens: TokenInfo,
285}
286
287// Access Key Models
288
289/// Service type for access keys
290#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(rename_all = "lowercase")]
292pub enum ServiceType {
293    Vectorizer,
294    Nexus,
295    Synap,
296    LessTokens,
297}
298
299impl std::fmt::Display for ServiceType {
300    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
301        match self {
302            ServiceType::Vectorizer => write!(f, "vectorizer"),
303            ServiceType::Nexus => write!(f, "nexus"),
304            ServiceType::Synap => write!(f, "synap"),
305            ServiceType::LessTokens => write!(f, "lesstokens"),
306        }
307    }
308}
309
310/// Access key permission
311#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
312#[serde(rename_all = "lowercase")]
313pub enum AccessKeyPermission {
314    Read,
315    Write,
316    Delete,
317    Admin,
318}
319
320/// Generate access key request
321#[derive(Debug, Clone, Serialize)]
322pub struct GenerateAccessKeyRequest {
323    pub service: ServiceType,
324    pub name: String,
325    pub permissions: Vec<AccessKeyPermission>,
326    #[serde(skip_serializing_if = "Option::is_none")]
327    pub expires_at: Option<DateTime<Utc>>,
328}
329
330/// Generate access key response
331#[derive(Debug, Clone, Serialize, Deserialize)]
332pub struct GenerateAccessKeyResponse {
333    pub success: bool,
334    pub access_key: String,
335    pub access_key_id: Uuid,
336    pub service: ServiceType,
337    pub name: String,
338    pub permissions: Vec<AccessKeyPermission>,
339    pub created_at: DateTime<Utc>,
340    #[serde(default)]
341    pub expires_at: Option<DateTime<Utc>>,
342}
343
344/// Access key information
345#[derive(Debug, Clone, Serialize, Deserialize)]
346pub struct AccessKeyInfo {
347    pub id: Uuid,
348    pub service: ServiceType,
349    pub name: String,
350    pub permissions: Vec<AccessKeyPermission>,
351    pub active: bool,
352    pub created_at: DateTime<Utc>,
353    #[serde(default)]
354    pub last_used_at: Option<DateTime<Utc>>,
355    #[serde(default)]
356    pub expires_at: Option<DateTime<Utc>>,
357}
358
359/// List access keys response
360#[derive(Debug, Clone, Serialize, Deserialize)]
361pub struct ListAccessKeysResponse {
362    pub keys: Vec<AccessKeyInfo>,
363}
364
365/// Revoke access key response
366#[derive(Debug, Clone, Serialize, Deserialize)]
367pub struct RevokeAccessKeyResponse {
368    pub success: bool,
369    pub message: String,
370}
hivehub_internal_sdk/models.rs

hivehub_internal_sdk/
models.rs
