1use super::*;
2
3#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
8#[serde(deny_unknown_fields, rename_all = "camelCase")]
9pub struct SpaceGrantResource {
10 pub id: String,
11 pub space_id: String,
12 pub principal: PrincipalRef,
13 pub capabilities: BTreeSet<SpaceCapability>,
14 pub path_prefixes: Vec<String>,
15 pub expires_at_ms: Option<u64>,
16 pub active: bool,
17 pub version: u64,
18}
19
20impl From<SpaceGrant> for SpaceGrantResource {
21 fn from(record: SpaceGrant) -> Self {
22 Self {
23 id: record.id,
24 space_id: record.space_id,
25 principal: record.principal,
26 capabilities: record.capabilities,
27 path_prefixes: record.path_prefixes,
28 expires_at_ms: record.expires_at_ms,
29 active: record.active,
30 version: record.version,
31 }
32 }
33}
34
35#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
36#[serde(deny_unknown_fields, rename_all = "camelCase")]
37pub struct SpaceCollaborationSessionResource {
38 pub id: String,
39 pub space_id: String,
40 pub principal: PrincipalRef,
41 pub delegation_id: Option<String>,
42 pub requested_mode: SpaceAccessMode,
43 pub effective_mode: SpaceAccessMode,
44 pub lifecycle: SpaceSessionLifecycle,
45 pub last_heartbeat_at_ms: u64,
46 pub expires_at_ms: u64,
47 pub version: u64,
48}
49
50impl From<SpaceCollaborationSession> for SpaceCollaborationSessionResource {
51 fn from(record: SpaceCollaborationSession) -> Self {
52 Self {
53 id: record.id,
54 space_id: record.space_id,
55 principal: record.principal,
56 delegation_id: record.delegation_id,
57 requested_mode: record.requested_mode,
58 effective_mode: record.effective_mode,
59 lifecycle: record.lifecycle,
60 last_heartbeat_at_ms: record.last_heartbeat_at_ms,
61 expires_at_ms: record.expires_at_ms,
62 version: record.version,
63 }
64 }
65}
66
67#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
68#[serde(deny_unknown_fields, rename_all = "camelCase")]
69pub struct SpaceWriteLeaseResource {
70 pub id: String,
71 pub space_id: String,
72 pub session_id: String,
73 pub fencing_token: u64,
74 pub version: u64,
75 pub acquired_at_ms: u64,
76 pub expires_at_ms: u64,
77 pub active: bool,
78}
79
80impl From<SpaceWriteLease> for SpaceWriteLeaseResource {
81 fn from(record: SpaceWriteLease) -> Self {
82 Self {
83 id: record.id,
84 space_id: record.space_id,
85 session_id: record.session_id,
86 fencing_token: record.fencing_token,
87 version: record.version,
88 acquired_at_ms: record.acquired_at_ms,
89 expires_at_ms: record.expires_at_ms,
90 active: record.active,
91 }
92 }
93}
94
95#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
96#[serde(deny_unknown_fields, rename_all = "camelCase")]
97pub struct DelegationResource {
98 pub id: String,
99 pub grantor_user_id: String,
100 pub delegate_agent_id: String,
101 pub computer_ids: BTreeSet<String>,
102 pub space_ids: BTreeSet<String>,
103 pub capabilities: BTreeSet<SpaceCapability>,
104 pub path_prefixes: Vec<String>,
105 pub purpose: String,
106 pub expires_at_ms: u64,
107 pub revoked_at_ms: Option<u64>,
108}
109
110impl From<DelegationRecord> for DelegationResource {
111 fn from(record: DelegationRecord) -> Self {
112 Self {
113 id: record.id,
114 grantor_user_id: record.grantor_user_id,
115 delegate_agent_id: record.delegate_agent_id,
116 computer_ids: record.computer_ids,
117 space_ids: record.space_ids,
118 capabilities: record.capabilities,
119 path_prefixes: record.path_prefixes,
120 purpose: record.purpose,
121 expires_at_ms: record.expires_at_ms,
122 revoked_at_ms: record.revoked_at_ms,
123 }
124 }
125}
126
127#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
128#[serde(deny_unknown_fields, rename_all = "camelCase")]
129pub struct ComputerResource {
130 pub id: String,
131 pub lifecycle: ComputerLifecycle,
132 pub capabilities: ProviderCapabilities,
133 pub owners: Vec<OwnerRef>,
134 pub version: u64,
135 pub created_at_ms: u64,
136 pub updated_at_ms: u64,
137}
138
139impl From<ComputerRecord> for ComputerResource {
140 fn from(record: ComputerRecord) -> Self {
141 Self {
142 id: record.id,
143 lifecycle: record.lifecycle,
144 capabilities: record.capabilities,
145 owners: record.owners,
146 version: record.version,
147 created_at_ms: record.created_at_ms,
148 updated_at_ms: record.updated_at_ms,
149 }
150 }
151}
152
153#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
154#[serde(deny_unknown_fields, rename_all = "camelCase")]
155pub struct SpaceResource {
156 pub id: String,
157 pub computer_id: String,
158 pub persistence: SpacePersistence,
159 pub lifecycle: SpaceLifecycle,
160 pub capabilities: ProviderCapabilities,
161 pub owners: Vec<OwnerRef>,
162 pub source_snapshot_id: Option<String>,
163 pub revision: u64,
164 pub version: u64,
165 pub created_at_ms: u64,
166 pub updated_at_ms: u64,
167}
168
169impl From<SpaceRecord> for SpaceResource {
170 fn from(record: SpaceRecord) -> Self {
171 Self {
172 id: record.id,
173 computer_id: record.computer_id,
174 persistence: record.persistence,
175 lifecycle: record.lifecycle,
176 capabilities: record.capabilities,
177 owners: record.owners,
178 source_snapshot_id: record.source_snapshot_id,
179 revision: record.revision,
180 version: record.version,
181 created_at_ms: record.created_at_ms,
182 updated_at_ms: record.updated_at_ms,
183 }
184 }
185}
186
187#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
188#[serde(deny_unknown_fields, rename_all = "camelCase")]
189pub struct SandboxResource {
190 pub id: String,
191 pub placement: SandboxPlacement,
192 pub lifecycle: SandboxLifecycle,
193 pub owners: Vec<OwnerRef>,
194 pub capabilities: ProviderCapabilities,
195 pub mounts: Vec<SandboxMountRecord>,
196 pub expires_at_ms: u64,
197 pub version: u64,
198 pub created_at_ms: u64,
199 pub updated_at_ms: u64,
200}
201
202impl From<SandboxRecord> for SandboxResource {
203 fn from(record: SandboxRecord) -> Self {
204 Self {
205 id: record.id,
206 placement: record.placement,
207 lifecycle: record.lifecycle,
208 owners: record.owners,
209 capabilities: record.capabilities,
210 mounts: record.mounts,
211 expires_at_ms: record.expires_at_ms,
212 version: record.version,
213 created_at_ms: record.created_at_ms,
214 updated_at_ms: record.updated_at_ms,
215 }
216 }
217}
218
219#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
220#[serde(deny_unknown_fields, rename_all = "camelCase")]
221pub struct SnapshotResource {
222 pub id: String,
223 pub source: SnapshotSourceRecord,
224 pub created_by: PrincipalRef,
225 pub lifecycle: SnapshotLifecycle,
226 pub digest: Option<String>,
227 pub size_bytes: Option<u64>,
228 pub created_at_ms: u64,
229}
230
231impl From<SnapshotRecord> for SnapshotResource {
232 fn from(record: SnapshotRecord) -> Self {
233 Self {
234 id: record.id,
235 source: record.source,
236 created_by: record.created_by,
237 lifecycle: record.lifecycle,
238 digest: record.digest,
239 size_bytes: record.size_bytes,
240 created_at_ms: record.created_at_ms,
241 }
242 }
243}
244
245#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
246#[serde(deny_unknown_fields, rename_all = "camelCase")]
247pub struct TemplateVersionResource {
248 pub template_id: String,
249 pub version: String,
250 pub provider: String,
251 pub created_by: PrincipalRef,
252 pub target: TemplateTarget,
253 pub base_snapshot_id: Option<String>,
254 pub resource_profile: BTreeMap<String, String>,
255 pub parameter_schema: BTreeMap<String, String>,
256 pub state: TemplateVersionState,
257 pub created_at_ms: u64,
258}
259
260impl From<TemplateVersionRecord> for TemplateVersionResource {
261 fn from(record: TemplateVersionRecord) -> Self {
262 Self {
263 template_id: record.template_id,
264 version: record.version,
265 provider: record.provider,
266 created_by: record.created_by,
267 target: record.target,
268 base_snapshot_id: record.base_snapshot_id,
269 resource_profile: record.resource_profile,
270 parameter_schema: record.parameter_schema,
271 state: record.state,
272 created_at_ms: record.created_at_ms,
273 }
274 }
275}
276
277#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
278#[serde(deny_unknown_fields, rename_all = "camelCase")]
279pub struct SpaceChangeSetResource {
280 pub id: String,
281 pub source_space_id: String,
282 pub target_space_id: String,
283 pub base_revision: u64,
284 pub created_by_session_id: String,
285 pub lifecycle: ChangeSetLifecycle,
286 pub created_at_ms: u64,
287}
288
289impl From<SpaceChangeSetRecord> for SpaceChangeSetResource {
290 fn from(record: SpaceChangeSetRecord) -> Self {
291 Self {
292 id: record.id,
293 source_space_id: record.source_space_id,
294 target_space_id: record.target_space_id,
295 base_revision: record.base_revision,
296 created_by_session_id: record.created_by_session_id,
297 lifecycle: record.lifecycle,
298 created_at_ms: record.created_at_ms,
299 }
300 }
301}
302
303#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
304#[serde(deny_unknown_fields, rename_all = "camelCase")]
305pub struct SpaceAccessTicketResource {
306 pub id: String,
307 pub space_id: String,
308 pub session_id: String,
309 pub mode: SpaceAccessMode,
310 pub capability_paths: BTreeMap<SpaceCapability, Vec<String>>,
311 pub fencing_token: Option<u64>,
312 pub expires_at_ms: u64,
313}
314
315#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
316#[serde(deny_unknown_fields, rename_all = "camelCase")]
317pub struct IssuedSpaceAccessTicketResource {
318 pub ticket: SpaceAccessTicketResource,
319 pub token: String,
320}
321
322impl From<IssuedSpaceAccessTicket> for IssuedSpaceAccessTicketResource {
323 fn from(issued: IssuedSpaceAccessTicket) -> Self {
324 Self {
325 ticket: SpaceAccessTicketResource {
326 id: issued.ticket.id,
327 space_id: issued.ticket.space_id,
328 session_id: issued.ticket.session_id,
329 mode: issued.ticket.mode,
330 capability_paths: issued.ticket.capability_paths,
331 fencing_token: issued.ticket.fencing_token,
332 expires_at_ms: issued.ticket.expires_at_ms,
333 },
334 token: issued.token,
335 }
336 }
337}
338
339#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
340#[serde(deny_unknown_fields, rename_all = "camelCase")]
341pub struct SpaceFileContent {
342 #[serde(with = "super::base64_bytes")]
343 pub bytes: Vec<u8>,
344}
345
346impl From<ProviderFileContent> for SpaceFileContent {
347 fn from(content: ProviderFileContent) -> Self {
348 Self {
349 bytes: content.bytes,
350 }
351 }
352}