Skip to main content

nominal_api/conjure/endpoints/scout/spatial/
spatial_service.rs

1use conjure_http::endpoint;
2/// The spatial asset service manages spatial assets (point clouds, etc.) and their metadata.
3/// Spatial asset data is stored in Dagger; Scout tracks metadata and references.
4#[conjure_http::conjure_endpoints(
5    name = "SpatialService",
6    use_legacy_error_serialization
7)]
8pub trait SpatialService {
9    /// Returns spatial asset metadata associated with a spatial asset rid.
10    #[endpoint(
11        method = GET,
12        path = "/spatial/v1/spatials/{spatialRid}",
13        name = "get",
14        produces = conjure_http::server::StdResponseSerializer
15    )]
16    fn get(
17        &self,
18        #[auth]
19        auth_: conjure_object::BearerToken,
20        #[path(
21            name = "spatialRid",
22            decoder = conjure_http::server::conjure::FromPlainDecoder,
23            log_as = "spatialRid",
24            safe
25        )]
26        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
27    ) -> Result<
28        super::super::super::super::objects::scout::spatial::api::Spatial,
29        conjure_http::private::Error,
30    >;
31    /// Returns spatial asset metadata for each given spatial asset rid.
32    #[endpoint(
33        method = POST,
34        path = "/spatial/v1/spatials/batchGet",
35        name = "batchGet",
36        produces = conjure_http::server::StdResponseSerializer
37    )]
38    fn batch_get(
39        &self,
40        #[auth]
41        auth_: conjure_object::BearerToken,
42        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
43        request: super::super::super::super::objects::scout::spatial::api::GetSpatialsRequest,
44    ) -> Result<
45        super::super::super::super::objects::scout::spatial::api::GetSpatialsResponse,
46        conjure_http::private::Error,
47    >;
48    /// Returns metadata about spatial assets that match a given query.
49    #[endpoint(
50        method = POST,
51        path = "/spatial/v1/spatials/search",
52        name = "search",
53        produces = conjure_http::server::StdResponseSerializer
54    )]
55    fn search(
56        &self,
57        #[auth]
58        auth_: conjure_object::BearerToken,
59        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
60        request: super::super::super::super::objects::scout::spatial::api::SearchSpatialsRequest,
61    ) -> Result<
62        super::super::super::super::objects::scout::spatial::api::SearchSpatialsResponse,
63        conjure_http::private::Error,
64    >;
65    /// Creates and persists a spatial asset entity with the given metadata.
66    #[endpoint(
67        method = POST,
68        path = "/spatial/v1/spatials",
69        name = "create",
70        produces = conjure_http::server::StdResponseSerializer
71    )]
72    fn create(
73        &self,
74        #[auth]
75        auth_: conjure_object::BearerToken,
76        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
77        request: super::super::super::super::objects::scout::spatial::api::CreateSpatialRequest,
78    ) -> Result<
79        super::super::super::super::objects::scout::spatial::api::Spatial,
80        conjure_http::private::Error,
81    >;
82    /// Updates the metadata for a spatial asset associated with the given rid.
83    #[endpoint(
84        method = PUT,
85        path = "/spatial/v1/spatials/{spatialRid}",
86        name = "updateMetadata",
87        produces = conjure_http::server::StdResponseSerializer
88    )]
89    fn update_metadata(
90        &self,
91        #[auth]
92        auth_: conjure_object::BearerToken,
93        #[path(
94            name = "spatialRid",
95            decoder = conjure_http::server::conjure::FromPlainDecoder,
96            log_as = "spatialRid",
97            safe
98        )]
99        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
100        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
101        request: super::super::super::super::objects::scout::spatial::api::UpdateSpatialMetadataRequest,
102    ) -> Result<
103        super::super::super::super::objects::scout::spatial::api::Spatial,
104        conjure_http::private::Error,
105    >;
106    #[endpoint(
107        method = GET,
108        path = "/spatial/v1/spatials/{spatialRid}/ingest-status",
109        name = "getIngestStatus",
110        produces = conjure_http::server::StdResponseSerializer
111    )]
112    fn get_ingest_status(
113        &self,
114        #[auth]
115        auth_: conjure_object::BearerToken,
116        #[path(
117            name = "spatialRid",
118            decoder = conjure_http::server::conjure::FromPlainDecoder,
119            log_as = "spatialRid",
120            safe
121        )]
122        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
123    ) -> Result<
124        super::super::super::super::objects::scout::spatial::api::SpatialIngestStatus,
125        conjure_http::private::Error,
126    >;
127    #[endpoint(
128        method = POST,
129        path = "/spatial/v1/spatials/batch-get-ingest-status",
130        name = "batchGetIngestStatus",
131        produces = conjure_http::server::conjure::CollectionResponseSerializer
132    )]
133    fn batch_get_ingest_status(
134        &self,
135        #[auth]
136        auth_: conjure_object::BearerToken,
137        #[body(
138            deserializer = conjure_http::server::StdRequestDeserializer,
139            log_as = "spatialRids",
140            safe
141        )]
142        spatial_rids: std::collections::BTreeSet<
143            super::super::super::super::objects::api::rids::SpatialRid,
144        >,
145    ) -> Result<
146        std::collections::BTreeMap<
147            super::super::super::super::objects::api::rids::SpatialRid,
148            super::super::super::super::objects::scout::spatial::api::SpatialIngestStatus,
149        >,
150        conjure_http::private::Error,
151    >;
152    /// Archives a spatial asset, excluding it from search. Can be unarchived.
153    #[endpoint(
154        method = PUT,
155        path = "/spatial/v1/spatials/{spatialRid}/archive",
156        name = "archive"
157    )]
158    fn archive(
159        &self,
160        #[auth]
161        auth_: conjure_object::BearerToken,
162        #[path(
163            name = "spatialRid",
164            decoder = conjure_http::server::conjure::FromPlainDecoder,
165            log_as = "spatialRid",
166            safe
167        )]
168        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
169    ) -> Result<(), conjure_http::private::Error>;
170    /// Unarchives a previously archived spatial asset.
171    #[endpoint(
172        method = PUT,
173        path = "/spatial/v1/spatials/{spatialRid}/unarchive",
174        name = "unarchive"
175    )]
176    fn unarchive(
177        &self,
178        #[auth]
179        auth_: conjure_object::BearerToken,
180        #[path(
181            name = "spatialRid",
182            decoder = conjure_http::server::conjure::FromPlainDecoder,
183            log_as = "spatialRid",
184            safe
185        )]
186        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
187    ) -> Result<(), conjure_http::private::Error>;
188    /// Imports a spatial data file (e.g. LAS, LAZ, PLY, PCAP).
189    /// Creates a new spatial asset, processes the file, and uploads the extracted data to Dagger.
190    #[endpoint(
191        method = POST,
192        path = "/spatial/v1/spatials/import-file",
193        name = "importFile",
194        produces = conjure_http::server::StdResponseSerializer
195    )]
196    fn import_file(
197        &self,
198        #[auth]
199        auth_: conjure_object::BearerToken,
200        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
201        request: super::super::super::super::objects::scout::spatial::api::ImportFileRequest,
202    ) -> Result<
203        super::super::super::super::objects::scout::spatial::api::ImportFileResponse,
204        conjure_http::private::Error,
205    >;
206}
207/// The spatial asset service manages spatial assets (point clouds, etc.) and their metadata.
208/// Spatial asset data is stored in Dagger; Scout tracks metadata and references.
209#[conjure_http::conjure_endpoints(
210    name = "SpatialService",
211    use_legacy_error_serialization
212)]
213pub trait AsyncSpatialService {
214    /// Returns spatial asset metadata associated with a spatial asset rid.
215    #[endpoint(
216        method = GET,
217        path = "/spatial/v1/spatials/{spatialRid}",
218        name = "get",
219        produces = conjure_http::server::StdResponseSerializer
220    )]
221    async fn get(
222        &self,
223        #[auth]
224        auth_: conjure_object::BearerToken,
225        #[path(
226            name = "spatialRid",
227            decoder = conjure_http::server::conjure::FromPlainDecoder,
228            log_as = "spatialRid",
229            safe
230        )]
231        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
232    ) -> Result<
233        super::super::super::super::objects::scout::spatial::api::Spatial,
234        conjure_http::private::Error,
235    >;
236    /// Returns spatial asset metadata for each given spatial asset rid.
237    #[endpoint(
238        method = POST,
239        path = "/spatial/v1/spatials/batchGet",
240        name = "batchGet",
241        produces = conjure_http::server::StdResponseSerializer
242    )]
243    async fn batch_get(
244        &self,
245        #[auth]
246        auth_: conjure_object::BearerToken,
247        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
248        request: super::super::super::super::objects::scout::spatial::api::GetSpatialsRequest,
249    ) -> Result<
250        super::super::super::super::objects::scout::spatial::api::GetSpatialsResponse,
251        conjure_http::private::Error,
252    >;
253    /// Returns metadata about spatial assets that match a given query.
254    #[endpoint(
255        method = POST,
256        path = "/spatial/v1/spatials/search",
257        name = "search",
258        produces = conjure_http::server::StdResponseSerializer
259    )]
260    async fn search(
261        &self,
262        #[auth]
263        auth_: conjure_object::BearerToken,
264        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
265        request: super::super::super::super::objects::scout::spatial::api::SearchSpatialsRequest,
266    ) -> Result<
267        super::super::super::super::objects::scout::spatial::api::SearchSpatialsResponse,
268        conjure_http::private::Error,
269    >;
270    /// Creates and persists a spatial asset entity with the given metadata.
271    #[endpoint(
272        method = POST,
273        path = "/spatial/v1/spatials",
274        name = "create",
275        produces = conjure_http::server::StdResponseSerializer
276    )]
277    async fn create(
278        &self,
279        #[auth]
280        auth_: conjure_object::BearerToken,
281        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
282        request: super::super::super::super::objects::scout::spatial::api::CreateSpatialRequest,
283    ) -> Result<
284        super::super::super::super::objects::scout::spatial::api::Spatial,
285        conjure_http::private::Error,
286    >;
287    /// Updates the metadata for a spatial asset associated with the given rid.
288    #[endpoint(
289        method = PUT,
290        path = "/spatial/v1/spatials/{spatialRid}",
291        name = "updateMetadata",
292        produces = conjure_http::server::StdResponseSerializer
293    )]
294    async fn update_metadata(
295        &self,
296        #[auth]
297        auth_: conjure_object::BearerToken,
298        #[path(
299            name = "spatialRid",
300            decoder = conjure_http::server::conjure::FromPlainDecoder,
301            log_as = "spatialRid",
302            safe
303        )]
304        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
305        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
306        request: super::super::super::super::objects::scout::spatial::api::UpdateSpatialMetadataRequest,
307    ) -> Result<
308        super::super::super::super::objects::scout::spatial::api::Spatial,
309        conjure_http::private::Error,
310    >;
311    #[endpoint(
312        method = GET,
313        path = "/spatial/v1/spatials/{spatialRid}/ingest-status",
314        name = "getIngestStatus",
315        produces = conjure_http::server::StdResponseSerializer
316    )]
317    async fn get_ingest_status(
318        &self,
319        #[auth]
320        auth_: conjure_object::BearerToken,
321        #[path(
322            name = "spatialRid",
323            decoder = conjure_http::server::conjure::FromPlainDecoder,
324            log_as = "spatialRid",
325            safe
326        )]
327        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
328    ) -> Result<
329        super::super::super::super::objects::scout::spatial::api::SpatialIngestStatus,
330        conjure_http::private::Error,
331    >;
332    #[endpoint(
333        method = POST,
334        path = "/spatial/v1/spatials/batch-get-ingest-status",
335        name = "batchGetIngestStatus",
336        produces = conjure_http::server::conjure::CollectionResponseSerializer
337    )]
338    async fn batch_get_ingest_status(
339        &self,
340        #[auth]
341        auth_: conjure_object::BearerToken,
342        #[body(
343            deserializer = conjure_http::server::StdRequestDeserializer,
344            log_as = "spatialRids",
345            safe
346        )]
347        spatial_rids: std::collections::BTreeSet<
348            super::super::super::super::objects::api::rids::SpatialRid,
349        >,
350    ) -> Result<
351        std::collections::BTreeMap<
352            super::super::super::super::objects::api::rids::SpatialRid,
353            super::super::super::super::objects::scout::spatial::api::SpatialIngestStatus,
354        >,
355        conjure_http::private::Error,
356    >;
357    /// Archives a spatial asset, excluding it from search. Can be unarchived.
358    #[endpoint(
359        method = PUT,
360        path = "/spatial/v1/spatials/{spatialRid}/archive",
361        name = "archive"
362    )]
363    async fn archive(
364        &self,
365        #[auth]
366        auth_: conjure_object::BearerToken,
367        #[path(
368            name = "spatialRid",
369            decoder = conjure_http::server::conjure::FromPlainDecoder,
370            log_as = "spatialRid",
371            safe
372        )]
373        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
374    ) -> Result<(), conjure_http::private::Error>;
375    /// Unarchives a previously archived spatial asset.
376    #[endpoint(
377        method = PUT,
378        path = "/spatial/v1/spatials/{spatialRid}/unarchive",
379        name = "unarchive"
380    )]
381    async fn unarchive(
382        &self,
383        #[auth]
384        auth_: conjure_object::BearerToken,
385        #[path(
386            name = "spatialRid",
387            decoder = conjure_http::server::conjure::FromPlainDecoder,
388            log_as = "spatialRid",
389            safe
390        )]
391        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
392    ) -> Result<(), conjure_http::private::Error>;
393    /// Imports a spatial data file (e.g. LAS, LAZ, PLY, PCAP).
394    /// Creates a new spatial asset, processes the file, and uploads the extracted data to Dagger.
395    #[endpoint(
396        method = POST,
397        path = "/spatial/v1/spatials/import-file",
398        name = "importFile",
399        produces = conjure_http::server::StdResponseSerializer
400    )]
401    async fn import_file(
402        &self,
403        #[auth]
404        auth_: conjure_object::BearerToken,
405        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
406        request: super::super::super::super::objects::scout::spatial::api::ImportFileRequest,
407    ) -> Result<
408        super::super::super::super::objects::scout::spatial::api::ImportFileResponse,
409        conjure_http::private::Error,
410    >;
411}
412/// The spatial asset service manages spatial assets (point clouds, etc.) and their metadata.
413/// Spatial asset data is stored in Dagger; Scout tracks metadata and references.
414#[conjure_http::conjure_endpoints(
415    name = "SpatialService",
416    use_legacy_error_serialization,
417    local
418)]
419pub trait LocalAsyncSpatialService {
420    /// Returns spatial asset metadata associated with a spatial asset rid.
421    #[endpoint(
422        method = GET,
423        path = "/spatial/v1/spatials/{spatialRid}",
424        name = "get",
425        produces = conjure_http::server::StdResponseSerializer
426    )]
427    async fn get(
428        &self,
429        #[auth]
430        auth_: conjure_object::BearerToken,
431        #[path(
432            name = "spatialRid",
433            decoder = conjure_http::server::conjure::FromPlainDecoder,
434            log_as = "spatialRid",
435            safe
436        )]
437        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
438    ) -> Result<
439        super::super::super::super::objects::scout::spatial::api::Spatial,
440        conjure_http::private::Error,
441    >;
442    /// Returns spatial asset metadata for each given spatial asset rid.
443    #[endpoint(
444        method = POST,
445        path = "/spatial/v1/spatials/batchGet",
446        name = "batchGet",
447        produces = conjure_http::server::StdResponseSerializer
448    )]
449    async fn batch_get(
450        &self,
451        #[auth]
452        auth_: conjure_object::BearerToken,
453        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
454        request: super::super::super::super::objects::scout::spatial::api::GetSpatialsRequest,
455    ) -> Result<
456        super::super::super::super::objects::scout::spatial::api::GetSpatialsResponse,
457        conjure_http::private::Error,
458    >;
459    /// Returns metadata about spatial assets that match a given query.
460    #[endpoint(
461        method = POST,
462        path = "/spatial/v1/spatials/search",
463        name = "search",
464        produces = conjure_http::server::StdResponseSerializer
465    )]
466    async fn search(
467        &self,
468        #[auth]
469        auth_: conjure_object::BearerToken,
470        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
471        request: super::super::super::super::objects::scout::spatial::api::SearchSpatialsRequest,
472    ) -> Result<
473        super::super::super::super::objects::scout::spatial::api::SearchSpatialsResponse,
474        conjure_http::private::Error,
475    >;
476    /// Creates and persists a spatial asset entity with the given metadata.
477    #[endpoint(
478        method = POST,
479        path = "/spatial/v1/spatials",
480        name = "create",
481        produces = conjure_http::server::StdResponseSerializer
482    )]
483    async fn create(
484        &self,
485        #[auth]
486        auth_: conjure_object::BearerToken,
487        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
488        request: super::super::super::super::objects::scout::spatial::api::CreateSpatialRequest,
489    ) -> Result<
490        super::super::super::super::objects::scout::spatial::api::Spatial,
491        conjure_http::private::Error,
492    >;
493    /// Updates the metadata for a spatial asset associated with the given rid.
494    #[endpoint(
495        method = PUT,
496        path = "/spatial/v1/spatials/{spatialRid}",
497        name = "updateMetadata",
498        produces = conjure_http::server::StdResponseSerializer
499    )]
500    async fn update_metadata(
501        &self,
502        #[auth]
503        auth_: conjure_object::BearerToken,
504        #[path(
505            name = "spatialRid",
506            decoder = conjure_http::server::conjure::FromPlainDecoder,
507            log_as = "spatialRid",
508            safe
509        )]
510        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
511        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
512        request: super::super::super::super::objects::scout::spatial::api::UpdateSpatialMetadataRequest,
513    ) -> Result<
514        super::super::super::super::objects::scout::spatial::api::Spatial,
515        conjure_http::private::Error,
516    >;
517    #[endpoint(
518        method = GET,
519        path = "/spatial/v1/spatials/{spatialRid}/ingest-status",
520        name = "getIngestStatus",
521        produces = conjure_http::server::StdResponseSerializer
522    )]
523    async fn get_ingest_status(
524        &self,
525        #[auth]
526        auth_: conjure_object::BearerToken,
527        #[path(
528            name = "spatialRid",
529            decoder = conjure_http::server::conjure::FromPlainDecoder,
530            log_as = "spatialRid",
531            safe
532        )]
533        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
534    ) -> Result<
535        super::super::super::super::objects::scout::spatial::api::SpatialIngestStatus,
536        conjure_http::private::Error,
537    >;
538    #[endpoint(
539        method = POST,
540        path = "/spatial/v1/spatials/batch-get-ingest-status",
541        name = "batchGetIngestStatus",
542        produces = conjure_http::server::conjure::CollectionResponseSerializer
543    )]
544    async fn batch_get_ingest_status(
545        &self,
546        #[auth]
547        auth_: conjure_object::BearerToken,
548        #[body(
549            deserializer = conjure_http::server::StdRequestDeserializer,
550            log_as = "spatialRids",
551            safe
552        )]
553        spatial_rids: std::collections::BTreeSet<
554            super::super::super::super::objects::api::rids::SpatialRid,
555        >,
556    ) -> Result<
557        std::collections::BTreeMap<
558            super::super::super::super::objects::api::rids::SpatialRid,
559            super::super::super::super::objects::scout::spatial::api::SpatialIngestStatus,
560        >,
561        conjure_http::private::Error,
562    >;
563    /// Archives a spatial asset, excluding it from search. Can be unarchived.
564    #[endpoint(
565        method = PUT,
566        path = "/spatial/v1/spatials/{spatialRid}/archive",
567        name = "archive"
568    )]
569    async fn archive(
570        &self,
571        #[auth]
572        auth_: conjure_object::BearerToken,
573        #[path(
574            name = "spatialRid",
575            decoder = conjure_http::server::conjure::FromPlainDecoder,
576            log_as = "spatialRid",
577            safe
578        )]
579        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
580    ) -> Result<(), conjure_http::private::Error>;
581    /// Unarchives a previously archived spatial asset.
582    #[endpoint(
583        method = PUT,
584        path = "/spatial/v1/spatials/{spatialRid}/unarchive",
585        name = "unarchive"
586    )]
587    async fn unarchive(
588        &self,
589        #[auth]
590        auth_: conjure_object::BearerToken,
591        #[path(
592            name = "spatialRid",
593            decoder = conjure_http::server::conjure::FromPlainDecoder,
594            log_as = "spatialRid",
595            safe
596        )]
597        spatial_rid: super::super::super::super::objects::api::rids::SpatialRid,
598    ) -> Result<(), conjure_http::private::Error>;
599    /// Imports a spatial data file (e.g. LAS, LAZ, PLY, PCAP).
600    /// Creates a new spatial asset, processes the file, and uploads the extracted data to Dagger.
601    #[endpoint(
602        method = POST,
603        path = "/spatial/v1/spatials/import-file",
604        name = "importFile",
605        produces = conjure_http::server::StdResponseSerializer
606    )]
607    async fn import_file(
608        &self,
609        #[auth]
610        auth_: conjure_object::BearerToken,
611        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
612        request: super::super::super::super::objects::scout::spatial::api::ImportFileRequest,
613    ) -> Result<
614        super::super::super::super::objects::scout::spatial::api::ImportFileResponse,
615        conjure_http::private::Error,
616    >;
617}