Skip to main content

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