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 created_by: PrincipalRef,
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 created_by: record.created_by,
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 persistence: SpacePersistence,
158 pub lifecycle: SpaceLifecycle,
159 pub capabilities: ProviderCapabilities,
160 pub source_snapshot_id: Option<String>,
161 pub revision: u64,
162 pub version: u64,
163 pub created_at_ms: u64,
164 pub updated_at_ms: u64,
165}
166
167impl From<SpaceRecord> for SpaceResource {
168 fn from(record: SpaceRecord) -> Self {
169 Self {
170 id: record.id,
171 persistence: record.persistence,
172 lifecycle: record.lifecycle,
173 capabilities: record.capabilities,
174 source_snapshot_id: record.source_snapshot_id,
175 revision: record.revision,
176 version: record.version,
177 created_at_ms: record.created_at_ms,
178 updated_at_ms: record.updated_at_ms,
179 }
180 }
181}
182
183#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
184#[serde(deny_unknown_fields, rename_all = "camelCase")]
185pub struct SandboxResource {
186 pub id: String,
187 pub placement: SandboxPlacement,
188 pub lifecycle: SandboxLifecycle,
189 pub owner: PrincipalRef,
190 pub capabilities: ProviderCapabilities,
191 pub mounts: Vec<SandboxMountRecord>,
192 pub expires_at_ms: u64,
193 pub version: u64,
194 pub created_at_ms: u64,
195 pub updated_at_ms: u64,
196}
197
198impl From<SandboxRecord> for SandboxResource {
199 fn from(record: SandboxRecord) -> Self {
200 Self {
201 id: record.id,
202 placement: record.placement,
203 lifecycle: record.lifecycle,
204 owner: record.owner,
205 capabilities: record.capabilities,
206 mounts: record.mounts,
207 expires_at_ms: record.expires_at_ms,
208 version: record.version,
209 created_at_ms: record.created_at_ms,
210 updated_at_ms: record.updated_at_ms,
211 }
212 }
213}
214
215#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
216#[serde(deny_unknown_fields, rename_all = "camelCase")]
217pub struct SnapshotResource {
218 pub id: String,
219 pub source: SnapshotSourceRecord,
220 pub created_by: PrincipalRef,
221 pub lifecycle: SnapshotLifecycle,
222 pub digest: Option<String>,
223 pub size_bytes: Option<u64>,
224 pub created_at_ms: u64,
225}
226
227impl From<SnapshotRecord> for SnapshotResource {
228 fn from(record: SnapshotRecord) -> Self {
229 Self {
230 id: record.id,
231 source: record.source,
232 created_by: record.created_by,
233 lifecycle: record.lifecycle,
234 digest: record.digest,
235 size_bytes: record.size_bytes,
236 created_at_ms: record.created_at_ms,
237 }
238 }
239}
240
241#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
242#[serde(deny_unknown_fields, rename_all = "camelCase")]
243pub struct TemplateVersionResource {
244 pub template_id: String,
245 pub version: String,
246 pub provider: String,
247 pub created_by: PrincipalRef,
248 pub target: TemplateTarget,
249 pub base_snapshot_id: Option<String>,
250 pub resource_profile: BTreeMap<String, String>,
251 pub parameter_schema: BTreeMap<String, String>,
252 pub state: TemplateVersionState,
253 pub created_at_ms: u64,
254}
255
256impl From<TemplateVersionRecord> for TemplateVersionResource {
257 fn from(record: TemplateVersionRecord) -> Self {
258 Self {
259 template_id: record.template_id,
260 version: record.version,
261 provider: record.provider,
262 created_by: record.created_by,
263 target: record.target,
264 base_snapshot_id: record.base_snapshot_id,
265 resource_profile: record.resource_profile,
266 parameter_schema: record.parameter_schema,
267 state: record.state,
268 created_at_ms: record.created_at_ms,
269 }
270 }
271}
272
273#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
274#[serde(deny_unknown_fields, rename_all = "camelCase")]
275pub struct SpaceChangeSetResource {
276 pub id: String,
277 pub source_space_id: String,
278 pub target_space_id: String,
279 pub base_revision: u64,
280 pub created_by_session_id: String,
281 pub lifecycle: ChangeSetLifecycle,
282 pub created_at_ms: u64,
283}
284
285impl From<SpaceChangeSetRecord> for SpaceChangeSetResource {
286 fn from(record: SpaceChangeSetRecord) -> Self {
287 Self {
288 id: record.id,
289 source_space_id: record.source_space_id,
290 target_space_id: record.target_space_id,
291 base_revision: record.base_revision,
292 created_by_session_id: record.created_by_session_id,
293 lifecycle: record.lifecycle,
294 created_at_ms: record.created_at_ms,
295 }
296 }
297}
298
299#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
300#[serde(deny_unknown_fields, rename_all = "camelCase")]
301pub struct SpaceAccessTicketResource {
302 pub id: String,
303 pub space_id: String,
304 pub session_id: String,
305 pub mode: SpaceAccessMode,
306 pub capability_paths: BTreeMap<SpaceCapability, Vec<String>>,
307 pub fencing_token: Option<u64>,
308 pub expires_at_ms: u64,
309}
310
311#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
312#[serde(deny_unknown_fields, rename_all = "camelCase")]
313pub struct IssuedSpaceAccessTicketResource {
314 pub ticket: SpaceAccessTicketResource,
315 pub token: String,
316}
317
318impl From<IssuedSpaceAccessTicket> for IssuedSpaceAccessTicketResource {
319 fn from(issued: IssuedSpaceAccessTicket) -> Self {
320 Self {
321 ticket: SpaceAccessTicketResource {
322 id: issued.ticket.id,
323 space_id: issued.ticket.space_id,
324 session_id: issued.ticket.session_id,
325 mode: issued.ticket.mode,
326 capability_paths: issued.ticket.capability_paths,
327 fencing_token: issued.ticket.fencing_token,
328 expires_at_ms: issued.ticket.expires_at_ms,
329 },
330 token: issued.token,
331 }
332 }
333}
334
335#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
336#[serde(deny_unknown_fields, rename_all = "camelCase")]
337pub struct SpaceFileContent {
338 #[serde(with = "super::base64_bytes")]
339 pub bytes: Vec<u8>,
340}
341
342impl From<ProviderFileContent> for SpaceFileContent {
343 fn from(content: ProviderFileContent) -> Self {
344 Self {
345 bytes: content.bytes,
346 }
347 }
348}