nominal_api/conjure/endpoints/scout/catalog/
catalog_service.rs

1use conjure_http::endpoint;
2/// The Catalog Service provides the ability to query for information about Datasets that are stored in
3/// the Nominal platform. A Dataset is the Nominal representation of data that has been uploaded to Nominal via
4/// a file, primarily CSV.
5#[conjure_http::conjure_endpoints(
6    name = "CatalogService",
7    use_legacy_error_serialization
8)]
9pub trait CatalogService {
10    #[endpoint(
11        method = GET,
12        path = "/catalog/v1/datasets/{datasetUuid}",
13        name = "getEnrichedDataset",
14        produces = conjure_http::server::StdResponseSerializer
15    )]
16    fn get_enriched_dataset(
17        &self,
18        #[auth]
19        auth_: conjure_object::BearerToken,
20        #[path(
21            name = "datasetUuid",
22            decoder = conjure_http::server::conjure::FromPlainDecoder,
23            log_as = "datasetUuid"
24        )]
25        dataset_uuid: conjure_object::Uuid,
26    ) -> Result<
27        super::super::super::super::objects::scout::catalog::EnrichedDataset,
28        conjure_http::private::Error,
29    >;
30    #[endpoint(
31        method = POST,
32        path = "/catalog/v1/datasets/multiple",
33        name = "getEnrichedDatasets",
34        produces = conjure_http::server::conjure::CollectionResponseSerializer
35    )]
36    fn get_enriched_datasets(
37        &self,
38        #[auth]
39        auth_: conjure_object::BearerToken,
40        #[body(
41            deserializer = conjure_http::server::StdRequestDeserializer,
42            log_as = "getDatasetsRequest"
43        )]
44        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
45    ) -> Result<
46        std::collections::BTreeSet<
47            super::super::super::super::objects::scout::catalog::EnrichedDataset,
48        >,
49        conjure_http::private::Error,
50    >;
51    #[endpoint(
52        method = GET,
53        path = "/catalog/v1/datasets-simple/{datasetUuid}",
54        name = "getDataset",
55        produces = conjure_http::server::StdResponseSerializer
56    )]
57    fn get_dataset(
58        &self,
59        #[auth]
60        auth_: conjure_object::BearerToken,
61        #[path(
62            name = "datasetUuid",
63            decoder = conjure_http::server::conjure::FromPlainDecoder,
64            log_as = "datasetUuid"
65        )]
66        dataset_uuid: conjure_object::Uuid,
67    ) -> Result<
68        super::super::super::super::objects::scout::catalog::Dataset,
69        conjure_http::private::Error,
70    >;
71    #[endpoint(
72        method = POST,
73        path = "/catalog/v1/datasets-simple/multiple",
74        name = "getDatasets",
75        produces = conjure_http::server::conjure::CollectionResponseSerializer
76    )]
77    fn get_datasets(
78        &self,
79        #[auth]
80        auth_: conjure_object::BearerToken,
81        #[body(
82            deserializer = conjure_http::server::StdRequestDeserializer,
83            log_as = "getDatasetsRequest"
84        )]
85        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
86    ) -> Result<
87        std::collections::BTreeSet<
88            super::super::super::super::objects::scout::catalog::Dataset,
89        >,
90        conjure_http::private::Error,
91    >;
92    /// Gets the subset of dataset RIDs that currently have external connection config attached.
93    #[endpoint(
94        method = POST,
95        path = "/catalog/v1/datasets-simple/external-config",
96        name = "getDatasetsWithExternalConnectionConfig",
97        produces = conjure_http::server::conjure::CollectionResponseSerializer
98    )]
99    fn get_datasets_with_external_connection_config(
100        &self,
101        #[auth]
102        auth_: conjure_object::BearerToken,
103        #[body(
104            deserializer = conjure_http::server::StdRequestDeserializer,
105            log_as = "getDatasetsRequest"
106        )]
107        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
108    ) -> Result<
109        std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
110        conjure_http::private::Error,
111    >;
112    /// Registers or updates external connection configuration for an existing dataset.
113    #[endpoint(
114        method = POST,
115        path = "/catalog/v1/datasets/external-config",
116        name = "registerExternalConnectionConfig",
117        produces = conjure_http::server::StdResponseSerializer
118    )]
119    fn register_external_connection_config(
120        &self,
121        #[auth]
122        auth_: conjure_object::BearerToken,
123        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
124        request: super::super::super::super::objects::scout::catalog::RegisterExternalConnectionConfigRequest,
125    ) -> Result<
126        super::super::super::super::objects::scout::catalog::EnrichedDataset,
127        conjure_http::private::Error,
128    >;
129    #[endpoint(
130        method = GET,
131        path = "/catalog/v1/dataset/{datasetRid}/file/{fileId}",
132        name = "getDatasetFile",
133        produces = conjure_http::server::StdResponseSerializer
134    )]
135    fn get_dataset_file(
136        &self,
137        #[auth]
138        auth_: conjure_object::BearerToken,
139        #[path(
140            name = "datasetRid",
141            decoder = conjure_http::server::conjure::FromPlainDecoder,
142            log_as = "datasetRid"
143        )]
144        dataset_rid: conjure_object::ResourceIdentifier,
145        #[path(
146            name = "fileId",
147            decoder = conjure_http::server::conjure::FromPlainDecoder,
148            log_as = "fileId",
149            safe
150        )]
151        file_id: super::super::super::super::objects::datasource::DatasetFileId,
152    ) -> Result<
153        super::super::super::super::objects::scout::catalog::DatasetFile,
154        conjure_http::private::Error,
155    >;
156    /// Returns dataset files for the given file IDs within a single dataset. Only returns files that
157    /// exist and belong to the specified dataset. Useful for checking ingestion status of many files at once.
158    #[endpoint(
159        method = POST,
160        path = "/catalog/v1/dataset-files/batchGet",
161        name = "batchGetDatasetFiles",
162        produces = conjure_http::server::conjure::CollectionResponseSerializer
163    )]
164    fn batch_get_dataset_files(
165        &self,
166        #[auth]
167        auth_: conjure_object::BearerToken,
168        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
169        request: super::super::super::super::objects::scout::catalog::BatchGetDatasetFilesRequest,
170    ) -> Result<
171        std::collections::BTreeMap<
172            super::super::super::super::objects::datasource::DatasetFileId,
173            super::super::super::super::objects::scout::catalog::DatasetFile,
174        >,
175        conjure_http::private::Error,
176    >;
177    #[endpoint(
178        method = GET,
179        path = "/catalog/v1/ingest-job/{ingestJobRid}/files",
180        name = "getDatasetFilesForJob",
181        produces = conjure_http::server::StdResponseSerializer
182    )]
183    fn get_dataset_files_for_job(
184        &self,
185        #[auth]
186        auth_: conjure_object::BearerToken,
187        #[path(
188            name = "ingestJobRid",
189            decoder = conjure_http::server::conjure::FromPlainDecoder,
190            log_as = "ingestJobRid"
191        )]
192        ingest_job_rid: conjure_object::ResourceIdentifier,
193        #[query(
194            name = "nextPageToken",
195            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
196            log_as = "nextPageToken"
197        )]
198        next_page_token: Option<String>,
199    ) -> Result<
200        super::super::super::super::objects::scout::catalog::DatasetFilesPage,
201        conjure_http::private::Error,
202    >;
203    #[endpoint(
204        method = POST,
205        path = "/catalog/v1/search-datasets-v2",
206        name = "searchDatasets",
207        produces = conjure_http::server::StdResponseSerializer
208    )]
209    fn search_datasets(
210        &self,
211        #[auth]
212        auth_: conjure_object::BearerToken,
213        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
214        request: super::super::super::super::objects::scout::catalog::SearchDatasetsRequest,
215    ) -> Result<
216        super::super::super::super::objects::scout::catalog::SearchDatasetsResponse,
217        conjure_http::private::Error,
218    >;
219    #[endpoint(
220        method = PUT,
221        path = "/catalog/v1/datasets/ingest-status-v2",
222        name = "updateDatasetIngestStatusV2",
223        produces = conjure_http::server::StdResponseSerializer
224    )]
225    fn update_dataset_ingest_status_v2(
226        &self,
227        #[auth]
228        auth_: conjure_object::BearerToken,
229        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
230        details: super::super::super::super::objects::scout::catalog::UpdateIngestStatusV2,
231    ) -> Result<
232        super::super::super::super::objects::api::IngestStatusV2,
233        conjure_http::private::Error,
234    >;
235    #[endpoint(
236        method = GET,
237        path = "/catalog/v1/datasets/{datasetRid}/ingest-progress-v2",
238        name = "getIngestProgressV2",
239        produces = conjure_http::server::StdResponseSerializer
240    )]
241    fn get_ingest_progress_v2(
242        &self,
243        #[auth]
244        auth_: conjure_object::BearerToken,
245        #[path(
246            name = "datasetRid",
247            decoder = conjure_http::server::conjure::FromPlainDecoder,
248            log_as = "datasetRid"
249        )]
250        dataset_rid: conjure_object::ResourceIdentifier,
251    ) -> Result<
252        super::super::super::super::objects::scout::catalog::IngestProgressV2,
253        conjure_http::private::Error,
254    >;
255    #[endpoint(
256        method = GET,
257        path = "/catalog/v1/datasets/{dataset}/handle",
258        name = "getHandleForDataset",
259        produces = conjure_http::server::conjure::CollectionResponseSerializer
260    )]
261    fn get_handle_for_dataset(
262        &self,
263        #[auth]
264        auth_: conjure_object::BearerToken,
265        #[path(
266            name = "dataset",
267            decoder = conjure_http::server::conjure::FromPlainDecoder
268        )]
269        dataset: conjure_object::Uuid,
270    ) -> Result<
271        Option<super::super::super::super::objects::scout::catalog::Handle>,
272        conjure_http::private::Error,
273    >;
274    #[endpoint(
275        method = POST,
276        path = "/catalog/v1/datasets",
277        name = "createDataset",
278        produces = conjure_http::server::StdResponseSerializer
279    )]
280    fn create_dataset(
281        &self,
282        #[auth]
283        auth_: conjure_object::BearerToken,
284        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
285        details: super::super::super::super::objects::scout::catalog::CreateDataset,
286    ) -> Result<
287        super::super::super::super::objects::scout::catalog::EnrichedDataset,
288        conjure_http::private::Error,
289    >;
290    /// Creates a dataset if the s3 path does not exist, otherwise updates the dataset
291    #[endpoint(
292        method = POST,
293        path = "/catalog/v1/datasets/create-or-update",
294        name = "createOrUpdateDataset",
295        produces = conjure_http::server::StdResponseSerializer
296    )]
297    fn create_or_update_dataset(
298        &self,
299        #[auth]
300        auth_: conjure_object::BearerToken,
301        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
302        details: super::super::super::super::objects::scout::catalog::CreateDataset,
303    ) -> Result<
304        super::super::super::super::objects::scout::catalog::EnrichedDataset,
305        conjure_http::private::Error,
306    >;
307    /// Creates a dataset with a specific UUID. This is useful for migrations and advanced use cases
308    /// where the dataset UUID must be controlled by the caller. Throws a conflict error if a dataset
309    /// with the specified UUID already exists. This endpoint is not intended for general use. Use /datasets instead to create a new dataset.
310    #[endpoint(
311        method = POST,
312        path = "/catalog/v1/datasets/with-uuid",
313        name = "createDatasetWithUuid",
314        produces = conjure_http::server::StdResponseSerializer
315    )]
316    fn create_dataset_with_uuid(
317        &self,
318        #[auth]
319        auth_: conjure_object::BearerToken,
320        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
321        request: super::super::super::super::objects::scout::catalog::CreateDatasetWithUuidRequest,
322    ) -> Result<
323        super::super::super::super::objects::scout::catalog::EnrichedDataset,
324        conjure_http::private::Error,
325    >;
326    /// Adds a single file to an existing dataset.
327    #[endpoint(
328        method = POST,
329        path = "/catalog/v1/datasets/{datasetRid}/add-file",
330        name = "addFileToDataset",
331        produces = conjure_http::server::StdResponseSerializer
332    )]
333    fn add_file_to_dataset(
334        &self,
335        #[auth]
336        auth_: conjure_object::BearerToken,
337        #[path(
338            name = "datasetRid",
339            decoder = conjure_http::server::conjure::FromPlainDecoder,
340            log_as = "datasetRid"
341        )]
342        dataset_rid: conjure_object::ResourceIdentifier,
343        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
344        request: super::super::super::super::objects::scout::catalog::AddFileToDataset,
345    ) -> Result<
346        super::super::super::super::objects::scout::catalog::DatasetFile,
347        conjure_http::private::Error,
348    >;
349    #[endpoint(
350        method = GET,
351        path = "/catalog/v1/datasets/{datasetRid}/files",
352        name = "listDatasetFiles",
353        produces = conjure_http::server::StdResponseSerializer
354    )]
355    fn list_dataset_files(
356        &self,
357        #[auth]
358        auth_: conjure_object::BearerToken,
359        #[path(
360            name = "datasetRid",
361            decoder = conjure_http::server::conjure::FromPlainDecoder,
362            log_as = "datasetRid"
363        )]
364        dataset_rid: conjure_object::ResourceIdentifier,
365        #[query(
366            name = "nextPageToken",
367            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
368            log_as = "nextPageToken"
369        )]
370        next_page_token: Option<String>,
371    ) -> Result<
372        super::super::super::super::objects::scout::catalog::DatasetFilesPage,
373        conjure_http::private::Error,
374    >;
375    #[endpoint(
376        method = POST,
377        path = "/catalog/v1/search-dataset-files",
378        name = "searchDatasetFiles",
379        produces = conjure_http::server::StdResponseSerializer
380    )]
381    fn search_dataset_files(
382        &self,
383        #[auth]
384        auth_: conjure_object::BearerToken,
385        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
386        request: super::super::super::super::objects::scout::catalog::SearchDatasetFilesRequest,
387    ) -> Result<
388        super::super::super::super::objects::scout::catalog::SearchDatasetFilesResponse,
389        conjure_http::private::Error,
390    >;
391    #[endpoint(
392        method = GET,
393        path = "/catalog/v1/datasets/{datasetRid}/{fileId}/uri",
394        name = "getDatasetFileUri",
395        produces = conjure_http::server::StdResponseSerializer
396    )]
397    fn get_dataset_file_uri(
398        &self,
399        #[auth]
400        auth_: conjure_object::BearerToken,
401        #[path(
402            name = "datasetRid",
403            decoder = conjure_http::server::conjure::FromPlainDecoder,
404            log_as = "datasetRid"
405        )]
406        dataset_rid: conjure_object::ResourceIdentifier,
407        #[path(
408            name = "fileId",
409            decoder = conjure_http::server::conjure::FromPlainDecoder,
410            log_as = "fileId",
411            safe
412        )]
413        file_id: super::super::super::super::objects::datasource::DatasetFileId,
414    ) -> Result<
415        super::super::super::super::objects::scout::catalog::DatasetFileUri,
416        conjure_http::private::Error,
417    >;
418    #[endpoint(
419        method = GET,
420        path = "/catalog/v1/videos/{videoFileRid}/uri",
421        name = "getVideoFileUri",
422        produces = conjure_http::server::StdResponseSerializer
423    )]
424    fn get_video_file_uri(
425        &self,
426        #[auth]
427        auth_: conjure_object::BearerToken,
428        #[path(
429            name = "videoFileRid",
430            decoder = conjure_http::server::conjure::FromPlainDecoder,
431            log_as = "videoFileRid"
432        )]
433        video_file_rid: conjure_object::ResourceIdentifier,
434    ) -> Result<
435        super::super::super::super::objects::scout::catalog::VideoFileUri,
436        conjure_http::private::Error,
437    >;
438    #[endpoint(
439        method = GET,
440        path = "/catalog/v1/datasets/{datasetRid}/{fileId}/origin-uris",
441        name = "getOriginFileUris",
442        produces = conjure_http::server::conjure::CollectionResponseSerializer
443    )]
444    fn get_origin_file_uris(
445        &self,
446        #[auth]
447        auth_: conjure_object::BearerToken,
448        #[path(
449            name = "datasetRid",
450            decoder = conjure_http::server::conjure::FromPlainDecoder,
451            log_as = "datasetRid"
452        )]
453        dataset_rid: conjure_object::ResourceIdentifier,
454        #[path(
455            name = "fileId",
456            decoder = conjure_http::server::conjure::FromPlainDecoder,
457            log_as = "fileId",
458            safe
459        )]
460        file_id: super::super::super::super::objects::datasource::DatasetFileId,
461    ) -> Result<
462        Vec<super::super::super::super::objects::scout::catalog::OriginFileUri>,
463        conjure_http::private::Error,
464    >;
465    #[endpoint(
466        method = PUT,
467        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/success",
468        name = "markFileIngestSuccessful",
469        produces = conjure_http::server::StdResponseSerializer
470    )]
471    fn mark_file_ingest_successful(
472        &self,
473        #[auth]
474        auth_: conjure_object::BearerToken,
475        #[path(
476            name = "datasetRid",
477            decoder = conjure_http::server::conjure::FromPlainDecoder,
478            log_as = "datasetRid"
479        )]
480        dataset_rid: conjure_object::ResourceIdentifier,
481        #[path(
482            name = "fileId",
483            decoder = conjure_http::server::conjure::FromPlainDecoder,
484            log_as = "fileId",
485            safe
486        )]
487        file_id: super::super::super::super::objects::datasource::DatasetFileId,
488        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
489        request: super::super::super::super::objects::scout::catalog::MarkFileIngestSuccessful,
490    ) -> Result<
491        super::super::super::super::objects::scout::catalog::DatasetFile,
492        conjure_http::private::Error,
493    >;
494    #[endpoint(
495        method = PUT,
496        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/error",
497        name = "markFileIngestError",
498        produces = conjure_http::server::StdResponseSerializer
499    )]
500    fn mark_file_ingest_error(
501        &self,
502        #[auth]
503        auth_: conjure_object::BearerToken,
504        #[path(
505            name = "datasetRid",
506            decoder = conjure_http::server::conjure::FromPlainDecoder,
507            log_as = "datasetRid"
508        )]
509        dataset_rid: conjure_object::ResourceIdentifier,
510        #[path(
511            name = "fileId",
512            decoder = conjure_http::server::conjure::FromPlainDecoder,
513            log_as = "fileId",
514            safe
515        )]
516        file_id: super::super::super::super::objects::datasource::DatasetFileId,
517        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
518        request: super::super::super::super::objects::scout::catalog::MarkFileIngestError,
519    ) -> Result<
520        super::super::super::super::objects::scout::catalog::DatasetFile,
521        conjure_http::private::Error,
522    >;
523    /// Updates file-type-specific metadata for a dataset file. Currently used to update video segment metadata
524    /// after video segmentation is complete.
525    #[endpoint(
526        method = PUT,
527        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/metadata",
528        name = "updateDatasetFileMetadata",
529        produces = conjure_http::server::StdResponseSerializer
530    )]
531    fn update_dataset_file_metadata(
532        &self,
533        #[auth]
534        auth_: conjure_object::BearerToken,
535        #[path(
536            name = "datasetRid",
537            decoder = conjure_http::server::conjure::FromPlainDecoder,
538            log_as = "datasetRid"
539        )]
540        dataset_rid: conjure_object::ResourceIdentifier,
541        #[path(
542            name = "fileId",
543            decoder = conjure_http::server::conjure::FromPlainDecoder,
544            log_as = "fileId",
545            safe
546        )]
547        file_id: super::super::super::super::objects::datasource::DatasetFileId,
548        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
549        metadata: super::super::super::super::objects::scout::catalog::DatasetFileMetadata,
550    ) -> Result<
551        super::super::super::super::objects::scout::catalog::DatasetFile,
552        conjure_http::private::Error,
553    >;
554    #[endpoint(
555        method = PUT,
556        path = "/catalog/v1/datasets/{datasetRid}",
557        name = "updateDatasetMetadata",
558        produces = conjure_http::server::StdResponseSerializer
559    )]
560    fn update_dataset_metadata(
561        &self,
562        #[auth]
563        auth_: conjure_object::BearerToken,
564        #[path(
565            name = "datasetRid",
566            decoder = conjure_http::server::conjure::FromPlainDecoder,
567            log_as = "datasetRid"
568        )]
569        dataset_rid: conjure_object::ResourceIdentifier,
570        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
571        request: super::super::super::super::objects::scout::catalog::UpdateDatasetMetadata,
572    ) -> Result<
573        super::super::super::super::objects::scout::catalog::EnrichedDataset,
574        conjure_http::private::Error,
575    >;
576    /// Returns a versioned derived definition. If commit is omitted, returns the latest commit on main.
577    #[endpoint(
578        method = GET,
579        path = "/catalog/v1/datasets/{datasetRid}/derived-definition",
580        name = "getDatasetDerivedDefinition",
581        produces = conjure_http::server::StdResponseSerializer
582    )]
583    fn get_dataset_derived_definition(
584        &self,
585        #[auth]
586        auth_: conjure_object::BearerToken,
587        #[path(
588            name = "datasetRid",
589            decoder = conjure_http::server::conjure::FromPlainDecoder,
590            log_as = "datasetRid"
591        )]
592        dataset_rid: conjure_object::ResourceIdentifier,
593        #[query(
594            name = "commit",
595            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
596            safe
597        )]
598        commit: Option<
599            super::super::super::super::objects::scout::versioning::api::CommitId,
600        >,
601    ) -> Result<
602        super::super::super::super::objects::scout::catalog::DerivedDefinition,
603        conjure_http::private::Error,
604    >;
605    /// Replaces the current derived definition by creating a permanent commit on main.
606    /// Throws if the dataset is not derived, if referenced datasets are unauthorized, or if latestCommit is stale.
607    #[endpoint(
608        method = POST,
609        path = "/catalog/v1/datasets/{datasetRid}/derived-definition/commit",
610        name = "commitDerivedDefinition",
611        produces = conjure_http::server::StdResponseSerializer
612    )]
613    fn commit_derived_definition(
614        &self,
615        #[auth]
616        auth_: conjure_object::BearerToken,
617        #[path(
618            name = "datasetRid",
619            decoder = conjure_http::server::conjure::FromPlainDecoder,
620            log_as = "datasetRid"
621        )]
622        dataset_rid: conjure_object::ResourceIdentifier,
623        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
624        request: super::super::super::super::objects::scout::catalog::CommitDerivedDefinitionRequest,
625    ) -> Result<
626        super::super::super::super::objects::scout::catalog::DerivedDefinition,
627        conjure_http::private::Error,
628    >;
629    /// Update the bounds for a dataset without updating bounds of files within the dataset. If the
630    /// current bounds of the dataset are not set, then the bounds of the request will be used. Otherwise,
631    /// the bounds will be min(current start, request start), max(current end, request end).
632    #[endpoint(
633        method = PUT,
634        path = "/catalog/v1/datasets/{rid}/bounds-from-streaming",
635        name = "updateGlobalDatasetBounds",
636        produces = conjure_http::server::StdResponseSerializer
637    )]
638    fn update_global_dataset_bounds(
639        &self,
640        #[auth]
641        auth_: conjure_object::BearerToken,
642        #[path(name = "rid", decoder = conjure_http::server::conjure::FromPlainDecoder)]
643        rid: conjure_object::ResourceIdentifier,
644        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
645        request: super::super::super::super::objects::scout::catalog::UpdateBoundsRequest,
646    ) -> Result<
647        super::super::super::super::objects::scout::catalog::Dataset,
648        conjure_http::private::Error,
649    >;
650    /// Archives a dataset, which will hide it from search results unless the includeArchived flag is set to true. The
651    /// dataset can still be directly accessed by its UUID/rid.
652    #[endpoint(
653        method = POST,
654        path = "/catalog/v1/datasets/{datasetRid}/archive",
655        name = "archiveDataset"
656    )]
657    fn archive_dataset(
658        &self,
659        #[auth]
660        auth_: conjure_object::BearerToken,
661        #[path(
662            name = "datasetRid",
663            decoder = conjure_http::server::conjure::FromPlainDecoder,
664            log_as = "datasetRid"
665        )]
666        dataset_rid: conjure_object::ResourceIdentifier,
667    ) -> Result<(), conjure_http::private::Error>;
668    /// Undoes the archiving of a dataset.
669    #[endpoint(
670        method = POST,
671        path = "/catalog/v1/datasets/{datasetRid}/unarchive",
672        name = "unarchiveDataset"
673    )]
674    fn unarchive_dataset(
675        &self,
676        #[auth]
677        auth_: conjure_object::BearerToken,
678        #[path(
679            name = "datasetRid",
680            decoder = conjure_http::server::conjure::FromPlainDecoder,
681            log_as = "datasetRid"
682        )]
683        dataset_rid: conjure_object::ResourceIdentifier,
684    ) -> Result<(), conjure_http::private::Error>;
685    #[endpoint(
686        method = GET,
687        path = "/catalog/v1/datasets/all-properties-labels",
688        name = "getAllPropertiesAndLabels",
689        produces = conjure_http::server::StdResponseSerializer
690    )]
691    fn get_all_properties_and_labels(
692        &self,
693        #[auth]
694        auth_: conjure_object::BearerToken,
695        #[query(
696            name = "workspaces",
697            decoder = conjure_http::server::conjure::FromPlainSeqDecoder<_>
698        )]
699        workspaces: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
700    ) -> Result<
701        super::super::super::super::objects::scout::catalog::AllPropertiesAndLabelsResponse,
702        conjure_http::private::Error,
703    >;
704    /// Returns the log dataset RID for the specified workspace if configured and accessible to the caller.
705    #[endpoint(
706        method = GET,
707        path = "/catalog/v1/workspaces/{workspaceRid}/log-dataset",
708        name = "getLogDatasetForWorkspace",
709        produces = conjure_http::server::conjure::CollectionResponseSerializer
710    )]
711    fn get_log_dataset_for_workspace(
712        &self,
713        #[auth]
714        auth_: conjure_object::BearerToken,
715        #[path(
716            name = "workspaceRid",
717            decoder = conjure_http::server::conjure::FromPlainDecoder,
718            log_as = "workspaceRid"
719        )]
720        workspace_rid: conjure_object::ResourceIdentifier,
721    ) -> Result<
722        Option<conjure_object::ResourceIdentifier>,
723        conjure_http::private::Error,
724    >;
725}
726/// The Catalog Service provides the ability to query for information about Datasets that are stored in
727/// the Nominal platform. A Dataset is the Nominal representation of data that has been uploaded to Nominal via
728/// a file, primarily CSV.
729#[conjure_http::conjure_endpoints(
730    name = "CatalogService",
731    use_legacy_error_serialization
732)]
733pub trait AsyncCatalogService {
734    #[endpoint(
735        method = GET,
736        path = "/catalog/v1/datasets/{datasetUuid}",
737        name = "getEnrichedDataset",
738        produces = conjure_http::server::StdResponseSerializer
739    )]
740    async fn get_enriched_dataset(
741        &self,
742        #[auth]
743        auth_: conjure_object::BearerToken,
744        #[path(
745            name = "datasetUuid",
746            decoder = conjure_http::server::conjure::FromPlainDecoder,
747            log_as = "datasetUuid"
748        )]
749        dataset_uuid: conjure_object::Uuid,
750    ) -> Result<
751        super::super::super::super::objects::scout::catalog::EnrichedDataset,
752        conjure_http::private::Error,
753    >;
754    #[endpoint(
755        method = POST,
756        path = "/catalog/v1/datasets/multiple",
757        name = "getEnrichedDatasets",
758        produces = conjure_http::server::conjure::CollectionResponseSerializer
759    )]
760    async fn get_enriched_datasets(
761        &self,
762        #[auth]
763        auth_: conjure_object::BearerToken,
764        #[body(
765            deserializer = conjure_http::server::StdRequestDeserializer,
766            log_as = "getDatasetsRequest"
767        )]
768        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
769    ) -> Result<
770        std::collections::BTreeSet<
771            super::super::super::super::objects::scout::catalog::EnrichedDataset,
772        >,
773        conjure_http::private::Error,
774    >;
775    #[endpoint(
776        method = GET,
777        path = "/catalog/v1/datasets-simple/{datasetUuid}",
778        name = "getDataset",
779        produces = conjure_http::server::StdResponseSerializer
780    )]
781    async fn get_dataset(
782        &self,
783        #[auth]
784        auth_: conjure_object::BearerToken,
785        #[path(
786            name = "datasetUuid",
787            decoder = conjure_http::server::conjure::FromPlainDecoder,
788            log_as = "datasetUuid"
789        )]
790        dataset_uuid: conjure_object::Uuid,
791    ) -> Result<
792        super::super::super::super::objects::scout::catalog::Dataset,
793        conjure_http::private::Error,
794    >;
795    #[endpoint(
796        method = POST,
797        path = "/catalog/v1/datasets-simple/multiple",
798        name = "getDatasets",
799        produces = conjure_http::server::conjure::CollectionResponseSerializer
800    )]
801    async fn get_datasets(
802        &self,
803        #[auth]
804        auth_: conjure_object::BearerToken,
805        #[body(
806            deserializer = conjure_http::server::StdRequestDeserializer,
807            log_as = "getDatasetsRequest"
808        )]
809        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
810    ) -> Result<
811        std::collections::BTreeSet<
812            super::super::super::super::objects::scout::catalog::Dataset,
813        >,
814        conjure_http::private::Error,
815    >;
816    /// Gets the subset of dataset RIDs that currently have external connection config attached.
817    #[endpoint(
818        method = POST,
819        path = "/catalog/v1/datasets-simple/external-config",
820        name = "getDatasetsWithExternalConnectionConfig",
821        produces = conjure_http::server::conjure::CollectionResponseSerializer
822    )]
823    async fn get_datasets_with_external_connection_config(
824        &self,
825        #[auth]
826        auth_: conjure_object::BearerToken,
827        #[body(
828            deserializer = conjure_http::server::StdRequestDeserializer,
829            log_as = "getDatasetsRequest"
830        )]
831        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
832    ) -> Result<
833        std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
834        conjure_http::private::Error,
835    >;
836    /// Registers or updates external connection configuration for an existing dataset.
837    #[endpoint(
838        method = POST,
839        path = "/catalog/v1/datasets/external-config",
840        name = "registerExternalConnectionConfig",
841        produces = conjure_http::server::StdResponseSerializer
842    )]
843    async fn register_external_connection_config(
844        &self,
845        #[auth]
846        auth_: conjure_object::BearerToken,
847        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
848        request: super::super::super::super::objects::scout::catalog::RegisterExternalConnectionConfigRequest,
849    ) -> Result<
850        super::super::super::super::objects::scout::catalog::EnrichedDataset,
851        conjure_http::private::Error,
852    >;
853    #[endpoint(
854        method = GET,
855        path = "/catalog/v1/dataset/{datasetRid}/file/{fileId}",
856        name = "getDatasetFile",
857        produces = conjure_http::server::StdResponseSerializer
858    )]
859    async fn get_dataset_file(
860        &self,
861        #[auth]
862        auth_: conjure_object::BearerToken,
863        #[path(
864            name = "datasetRid",
865            decoder = conjure_http::server::conjure::FromPlainDecoder,
866            log_as = "datasetRid"
867        )]
868        dataset_rid: conjure_object::ResourceIdentifier,
869        #[path(
870            name = "fileId",
871            decoder = conjure_http::server::conjure::FromPlainDecoder,
872            log_as = "fileId",
873            safe
874        )]
875        file_id: super::super::super::super::objects::datasource::DatasetFileId,
876    ) -> Result<
877        super::super::super::super::objects::scout::catalog::DatasetFile,
878        conjure_http::private::Error,
879    >;
880    /// Returns dataset files for the given file IDs within a single dataset. Only returns files that
881    /// exist and belong to the specified dataset. Useful for checking ingestion status of many files at once.
882    #[endpoint(
883        method = POST,
884        path = "/catalog/v1/dataset-files/batchGet",
885        name = "batchGetDatasetFiles",
886        produces = conjure_http::server::conjure::CollectionResponseSerializer
887    )]
888    async fn batch_get_dataset_files(
889        &self,
890        #[auth]
891        auth_: conjure_object::BearerToken,
892        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
893        request: super::super::super::super::objects::scout::catalog::BatchGetDatasetFilesRequest,
894    ) -> Result<
895        std::collections::BTreeMap<
896            super::super::super::super::objects::datasource::DatasetFileId,
897            super::super::super::super::objects::scout::catalog::DatasetFile,
898        >,
899        conjure_http::private::Error,
900    >;
901    #[endpoint(
902        method = GET,
903        path = "/catalog/v1/ingest-job/{ingestJobRid}/files",
904        name = "getDatasetFilesForJob",
905        produces = conjure_http::server::StdResponseSerializer
906    )]
907    async fn get_dataset_files_for_job(
908        &self,
909        #[auth]
910        auth_: conjure_object::BearerToken,
911        #[path(
912            name = "ingestJobRid",
913            decoder = conjure_http::server::conjure::FromPlainDecoder,
914            log_as = "ingestJobRid"
915        )]
916        ingest_job_rid: conjure_object::ResourceIdentifier,
917        #[query(
918            name = "nextPageToken",
919            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
920            log_as = "nextPageToken"
921        )]
922        next_page_token: Option<String>,
923    ) -> Result<
924        super::super::super::super::objects::scout::catalog::DatasetFilesPage,
925        conjure_http::private::Error,
926    >;
927    #[endpoint(
928        method = POST,
929        path = "/catalog/v1/search-datasets-v2",
930        name = "searchDatasets",
931        produces = conjure_http::server::StdResponseSerializer
932    )]
933    async fn search_datasets(
934        &self,
935        #[auth]
936        auth_: conjure_object::BearerToken,
937        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
938        request: super::super::super::super::objects::scout::catalog::SearchDatasetsRequest,
939    ) -> Result<
940        super::super::super::super::objects::scout::catalog::SearchDatasetsResponse,
941        conjure_http::private::Error,
942    >;
943    #[endpoint(
944        method = PUT,
945        path = "/catalog/v1/datasets/ingest-status-v2",
946        name = "updateDatasetIngestStatusV2",
947        produces = conjure_http::server::StdResponseSerializer
948    )]
949    async fn update_dataset_ingest_status_v2(
950        &self,
951        #[auth]
952        auth_: conjure_object::BearerToken,
953        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
954        details: super::super::super::super::objects::scout::catalog::UpdateIngestStatusV2,
955    ) -> Result<
956        super::super::super::super::objects::api::IngestStatusV2,
957        conjure_http::private::Error,
958    >;
959    #[endpoint(
960        method = GET,
961        path = "/catalog/v1/datasets/{datasetRid}/ingest-progress-v2",
962        name = "getIngestProgressV2",
963        produces = conjure_http::server::StdResponseSerializer
964    )]
965    async fn get_ingest_progress_v2(
966        &self,
967        #[auth]
968        auth_: conjure_object::BearerToken,
969        #[path(
970            name = "datasetRid",
971            decoder = conjure_http::server::conjure::FromPlainDecoder,
972            log_as = "datasetRid"
973        )]
974        dataset_rid: conjure_object::ResourceIdentifier,
975    ) -> Result<
976        super::super::super::super::objects::scout::catalog::IngestProgressV2,
977        conjure_http::private::Error,
978    >;
979    #[endpoint(
980        method = GET,
981        path = "/catalog/v1/datasets/{dataset}/handle",
982        name = "getHandleForDataset",
983        produces = conjure_http::server::conjure::CollectionResponseSerializer
984    )]
985    async fn get_handle_for_dataset(
986        &self,
987        #[auth]
988        auth_: conjure_object::BearerToken,
989        #[path(
990            name = "dataset",
991            decoder = conjure_http::server::conjure::FromPlainDecoder
992        )]
993        dataset: conjure_object::Uuid,
994    ) -> Result<
995        Option<super::super::super::super::objects::scout::catalog::Handle>,
996        conjure_http::private::Error,
997    >;
998    #[endpoint(
999        method = POST,
1000        path = "/catalog/v1/datasets",
1001        name = "createDataset",
1002        produces = conjure_http::server::StdResponseSerializer
1003    )]
1004    async fn create_dataset(
1005        &self,
1006        #[auth]
1007        auth_: conjure_object::BearerToken,
1008        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1009        details: super::super::super::super::objects::scout::catalog::CreateDataset,
1010    ) -> Result<
1011        super::super::super::super::objects::scout::catalog::EnrichedDataset,
1012        conjure_http::private::Error,
1013    >;
1014    /// Creates a dataset if the s3 path does not exist, otherwise updates the dataset
1015    #[endpoint(
1016        method = POST,
1017        path = "/catalog/v1/datasets/create-or-update",
1018        name = "createOrUpdateDataset",
1019        produces = conjure_http::server::StdResponseSerializer
1020    )]
1021    async fn create_or_update_dataset(
1022        &self,
1023        #[auth]
1024        auth_: conjure_object::BearerToken,
1025        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1026        details: super::super::super::super::objects::scout::catalog::CreateDataset,
1027    ) -> Result<
1028        super::super::super::super::objects::scout::catalog::EnrichedDataset,
1029        conjure_http::private::Error,
1030    >;
1031    /// Creates a dataset with a specific UUID. This is useful for migrations and advanced use cases
1032    /// where the dataset UUID must be controlled by the caller. Throws a conflict error if a dataset
1033    /// with the specified UUID already exists. This endpoint is not intended for general use. Use /datasets instead to create a new dataset.
1034    #[endpoint(
1035        method = POST,
1036        path = "/catalog/v1/datasets/with-uuid",
1037        name = "createDatasetWithUuid",
1038        produces = conjure_http::server::StdResponseSerializer
1039    )]
1040    async fn create_dataset_with_uuid(
1041        &self,
1042        #[auth]
1043        auth_: conjure_object::BearerToken,
1044        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1045        request: super::super::super::super::objects::scout::catalog::CreateDatasetWithUuidRequest,
1046    ) -> Result<
1047        super::super::super::super::objects::scout::catalog::EnrichedDataset,
1048        conjure_http::private::Error,
1049    >;
1050    /// Adds a single file to an existing dataset.
1051    #[endpoint(
1052        method = POST,
1053        path = "/catalog/v1/datasets/{datasetRid}/add-file",
1054        name = "addFileToDataset",
1055        produces = conjure_http::server::StdResponseSerializer
1056    )]
1057    async fn add_file_to_dataset(
1058        &self,
1059        #[auth]
1060        auth_: conjure_object::BearerToken,
1061        #[path(
1062            name = "datasetRid",
1063            decoder = conjure_http::server::conjure::FromPlainDecoder,
1064            log_as = "datasetRid"
1065        )]
1066        dataset_rid: conjure_object::ResourceIdentifier,
1067        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1068        request: super::super::super::super::objects::scout::catalog::AddFileToDataset,
1069    ) -> Result<
1070        super::super::super::super::objects::scout::catalog::DatasetFile,
1071        conjure_http::private::Error,
1072    >;
1073    #[endpoint(
1074        method = GET,
1075        path = "/catalog/v1/datasets/{datasetRid}/files",
1076        name = "listDatasetFiles",
1077        produces = conjure_http::server::StdResponseSerializer
1078    )]
1079    async fn list_dataset_files(
1080        &self,
1081        #[auth]
1082        auth_: conjure_object::BearerToken,
1083        #[path(
1084            name = "datasetRid",
1085            decoder = conjure_http::server::conjure::FromPlainDecoder,
1086            log_as = "datasetRid"
1087        )]
1088        dataset_rid: conjure_object::ResourceIdentifier,
1089        #[query(
1090            name = "nextPageToken",
1091            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
1092            log_as = "nextPageToken"
1093        )]
1094        next_page_token: Option<String>,
1095    ) -> Result<
1096        super::super::super::super::objects::scout::catalog::DatasetFilesPage,
1097        conjure_http::private::Error,
1098    >;
1099    #[endpoint(
1100        method = POST,
1101        path = "/catalog/v1/search-dataset-files",
1102        name = "searchDatasetFiles",
1103        produces = conjure_http::server::StdResponseSerializer
1104    )]
1105    async fn search_dataset_files(
1106        &self,
1107        #[auth]
1108        auth_: conjure_object::BearerToken,
1109        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1110        request: super::super::super::super::objects::scout::catalog::SearchDatasetFilesRequest,
1111    ) -> Result<
1112        super::super::super::super::objects::scout::catalog::SearchDatasetFilesResponse,
1113        conjure_http::private::Error,
1114    >;
1115    #[endpoint(
1116        method = GET,
1117        path = "/catalog/v1/datasets/{datasetRid}/{fileId}/uri",
1118        name = "getDatasetFileUri",
1119        produces = conjure_http::server::StdResponseSerializer
1120    )]
1121    async fn get_dataset_file_uri(
1122        &self,
1123        #[auth]
1124        auth_: conjure_object::BearerToken,
1125        #[path(
1126            name = "datasetRid",
1127            decoder = conjure_http::server::conjure::FromPlainDecoder,
1128            log_as = "datasetRid"
1129        )]
1130        dataset_rid: conjure_object::ResourceIdentifier,
1131        #[path(
1132            name = "fileId",
1133            decoder = conjure_http::server::conjure::FromPlainDecoder,
1134            log_as = "fileId",
1135            safe
1136        )]
1137        file_id: super::super::super::super::objects::datasource::DatasetFileId,
1138    ) -> Result<
1139        super::super::super::super::objects::scout::catalog::DatasetFileUri,
1140        conjure_http::private::Error,
1141    >;
1142    #[endpoint(
1143        method = GET,
1144        path = "/catalog/v1/videos/{videoFileRid}/uri",
1145        name = "getVideoFileUri",
1146        produces = conjure_http::server::StdResponseSerializer
1147    )]
1148    async fn get_video_file_uri(
1149        &self,
1150        #[auth]
1151        auth_: conjure_object::BearerToken,
1152        #[path(
1153            name = "videoFileRid",
1154            decoder = conjure_http::server::conjure::FromPlainDecoder,
1155            log_as = "videoFileRid"
1156        )]
1157        video_file_rid: conjure_object::ResourceIdentifier,
1158    ) -> Result<
1159        super::super::super::super::objects::scout::catalog::VideoFileUri,
1160        conjure_http::private::Error,
1161    >;
1162    #[endpoint(
1163        method = GET,
1164        path = "/catalog/v1/datasets/{datasetRid}/{fileId}/origin-uris",
1165        name = "getOriginFileUris",
1166        produces = conjure_http::server::conjure::CollectionResponseSerializer
1167    )]
1168    async fn get_origin_file_uris(
1169        &self,
1170        #[auth]
1171        auth_: conjure_object::BearerToken,
1172        #[path(
1173            name = "datasetRid",
1174            decoder = conjure_http::server::conjure::FromPlainDecoder,
1175            log_as = "datasetRid"
1176        )]
1177        dataset_rid: conjure_object::ResourceIdentifier,
1178        #[path(
1179            name = "fileId",
1180            decoder = conjure_http::server::conjure::FromPlainDecoder,
1181            log_as = "fileId",
1182            safe
1183        )]
1184        file_id: super::super::super::super::objects::datasource::DatasetFileId,
1185    ) -> Result<
1186        Vec<super::super::super::super::objects::scout::catalog::OriginFileUri>,
1187        conjure_http::private::Error,
1188    >;
1189    #[endpoint(
1190        method = PUT,
1191        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/success",
1192        name = "markFileIngestSuccessful",
1193        produces = conjure_http::server::StdResponseSerializer
1194    )]
1195    async fn mark_file_ingest_successful(
1196        &self,
1197        #[auth]
1198        auth_: conjure_object::BearerToken,
1199        #[path(
1200            name = "datasetRid",
1201            decoder = conjure_http::server::conjure::FromPlainDecoder,
1202            log_as = "datasetRid"
1203        )]
1204        dataset_rid: conjure_object::ResourceIdentifier,
1205        #[path(
1206            name = "fileId",
1207            decoder = conjure_http::server::conjure::FromPlainDecoder,
1208            log_as = "fileId",
1209            safe
1210        )]
1211        file_id: super::super::super::super::objects::datasource::DatasetFileId,
1212        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
1213        request: super::super::super::super::objects::scout::catalog::MarkFileIngestSuccessful,
1214    ) -> Result<
1215        super::super::super::super::objects::scout::catalog::DatasetFile,
1216        conjure_http::private::Error,
1217    >;
1218    #[endpoint(
1219        method = PUT,
1220        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/error",
1221        name = "markFileIngestError",
1222        produces = conjure_http::server::StdResponseSerializer
1223    )]
1224    async fn mark_file_ingest_error(
1225        &self,
1226        #[auth]
1227        auth_: conjure_object::BearerToken,
1228        #[path(
1229            name = "datasetRid",
1230            decoder = conjure_http::server::conjure::FromPlainDecoder,
1231            log_as = "datasetRid"
1232        )]
1233        dataset_rid: conjure_object::ResourceIdentifier,
1234        #[path(
1235            name = "fileId",
1236            decoder = conjure_http::server::conjure::FromPlainDecoder,
1237            log_as = "fileId",
1238            safe
1239        )]
1240        file_id: super::super::super::super::objects::datasource::DatasetFileId,
1241        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1242        request: super::super::super::super::objects::scout::catalog::MarkFileIngestError,
1243    ) -> Result<
1244        super::super::super::super::objects::scout::catalog::DatasetFile,
1245        conjure_http::private::Error,
1246    >;
1247    /// Updates file-type-specific metadata for a dataset file. Currently used to update video segment metadata
1248    /// after video segmentation is complete.
1249    #[endpoint(
1250        method = PUT,
1251        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/metadata",
1252        name = "updateDatasetFileMetadata",
1253        produces = conjure_http::server::StdResponseSerializer
1254    )]
1255    async fn update_dataset_file_metadata(
1256        &self,
1257        #[auth]
1258        auth_: conjure_object::BearerToken,
1259        #[path(
1260            name = "datasetRid",
1261            decoder = conjure_http::server::conjure::FromPlainDecoder,
1262            log_as = "datasetRid"
1263        )]
1264        dataset_rid: conjure_object::ResourceIdentifier,
1265        #[path(
1266            name = "fileId",
1267            decoder = conjure_http::server::conjure::FromPlainDecoder,
1268            log_as = "fileId",
1269            safe
1270        )]
1271        file_id: super::super::super::super::objects::datasource::DatasetFileId,
1272        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1273        metadata: super::super::super::super::objects::scout::catalog::DatasetFileMetadata,
1274    ) -> Result<
1275        super::super::super::super::objects::scout::catalog::DatasetFile,
1276        conjure_http::private::Error,
1277    >;
1278    #[endpoint(
1279        method = PUT,
1280        path = "/catalog/v1/datasets/{datasetRid}",
1281        name = "updateDatasetMetadata",
1282        produces = conjure_http::server::StdResponseSerializer
1283    )]
1284    async fn update_dataset_metadata(
1285        &self,
1286        #[auth]
1287        auth_: conjure_object::BearerToken,
1288        #[path(
1289            name = "datasetRid",
1290            decoder = conjure_http::server::conjure::FromPlainDecoder,
1291            log_as = "datasetRid"
1292        )]
1293        dataset_rid: conjure_object::ResourceIdentifier,
1294        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1295        request: super::super::super::super::objects::scout::catalog::UpdateDatasetMetadata,
1296    ) -> Result<
1297        super::super::super::super::objects::scout::catalog::EnrichedDataset,
1298        conjure_http::private::Error,
1299    >;
1300    /// Returns a versioned derived definition. If commit is omitted, returns the latest commit on main.
1301    #[endpoint(
1302        method = GET,
1303        path = "/catalog/v1/datasets/{datasetRid}/derived-definition",
1304        name = "getDatasetDerivedDefinition",
1305        produces = conjure_http::server::StdResponseSerializer
1306    )]
1307    async fn get_dataset_derived_definition(
1308        &self,
1309        #[auth]
1310        auth_: conjure_object::BearerToken,
1311        #[path(
1312            name = "datasetRid",
1313            decoder = conjure_http::server::conjure::FromPlainDecoder,
1314            log_as = "datasetRid"
1315        )]
1316        dataset_rid: conjure_object::ResourceIdentifier,
1317        #[query(
1318            name = "commit",
1319            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
1320            safe
1321        )]
1322        commit: Option<
1323            super::super::super::super::objects::scout::versioning::api::CommitId,
1324        >,
1325    ) -> Result<
1326        super::super::super::super::objects::scout::catalog::DerivedDefinition,
1327        conjure_http::private::Error,
1328    >;
1329    /// Replaces the current derived definition by creating a permanent commit on main.
1330    /// Throws if the dataset is not derived, if referenced datasets are unauthorized, or if latestCommit is stale.
1331    #[endpoint(
1332        method = POST,
1333        path = "/catalog/v1/datasets/{datasetRid}/derived-definition/commit",
1334        name = "commitDerivedDefinition",
1335        produces = conjure_http::server::StdResponseSerializer
1336    )]
1337    async fn commit_derived_definition(
1338        &self,
1339        #[auth]
1340        auth_: conjure_object::BearerToken,
1341        #[path(
1342            name = "datasetRid",
1343            decoder = conjure_http::server::conjure::FromPlainDecoder,
1344            log_as = "datasetRid"
1345        )]
1346        dataset_rid: conjure_object::ResourceIdentifier,
1347        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1348        request: super::super::super::super::objects::scout::catalog::CommitDerivedDefinitionRequest,
1349    ) -> Result<
1350        super::super::super::super::objects::scout::catalog::DerivedDefinition,
1351        conjure_http::private::Error,
1352    >;
1353    /// Update the bounds for a dataset without updating bounds of files within the dataset. If the
1354    /// current bounds of the dataset are not set, then the bounds of the request will be used. Otherwise,
1355    /// the bounds will be min(current start, request start), max(current end, request end).
1356    #[endpoint(
1357        method = PUT,
1358        path = "/catalog/v1/datasets/{rid}/bounds-from-streaming",
1359        name = "updateGlobalDatasetBounds",
1360        produces = conjure_http::server::StdResponseSerializer
1361    )]
1362    async fn update_global_dataset_bounds(
1363        &self,
1364        #[auth]
1365        auth_: conjure_object::BearerToken,
1366        #[path(name = "rid", decoder = conjure_http::server::conjure::FromPlainDecoder)]
1367        rid: conjure_object::ResourceIdentifier,
1368        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
1369        request: super::super::super::super::objects::scout::catalog::UpdateBoundsRequest,
1370    ) -> Result<
1371        super::super::super::super::objects::scout::catalog::Dataset,
1372        conjure_http::private::Error,
1373    >;
1374    /// Archives a dataset, which will hide it from search results unless the includeArchived flag is set to true. The
1375    /// dataset can still be directly accessed by its UUID/rid.
1376    #[endpoint(
1377        method = POST,
1378        path = "/catalog/v1/datasets/{datasetRid}/archive",
1379        name = "archiveDataset"
1380    )]
1381    async fn archive_dataset(
1382        &self,
1383        #[auth]
1384        auth_: conjure_object::BearerToken,
1385        #[path(
1386            name = "datasetRid",
1387            decoder = conjure_http::server::conjure::FromPlainDecoder,
1388            log_as = "datasetRid"
1389        )]
1390        dataset_rid: conjure_object::ResourceIdentifier,
1391    ) -> Result<(), conjure_http::private::Error>;
1392    /// Undoes the archiving of a dataset.
1393    #[endpoint(
1394        method = POST,
1395        path = "/catalog/v1/datasets/{datasetRid}/unarchive",
1396        name = "unarchiveDataset"
1397    )]
1398    async fn unarchive_dataset(
1399        &self,
1400        #[auth]
1401        auth_: conjure_object::BearerToken,
1402        #[path(
1403            name = "datasetRid",
1404            decoder = conjure_http::server::conjure::FromPlainDecoder,
1405            log_as = "datasetRid"
1406        )]
1407        dataset_rid: conjure_object::ResourceIdentifier,
1408    ) -> Result<(), conjure_http::private::Error>;
1409    #[endpoint(
1410        method = GET,
1411        path = "/catalog/v1/datasets/all-properties-labels",
1412        name = "getAllPropertiesAndLabels",
1413        produces = conjure_http::server::StdResponseSerializer
1414    )]
1415    async fn get_all_properties_and_labels(
1416        &self,
1417        #[auth]
1418        auth_: conjure_object::BearerToken,
1419        #[query(
1420            name = "workspaces",
1421            decoder = conjure_http::server::conjure::FromPlainSeqDecoder<_>
1422        )]
1423        workspaces: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
1424    ) -> Result<
1425        super::super::super::super::objects::scout::catalog::AllPropertiesAndLabelsResponse,
1426        conjure_http::private::Error,
1427    >;
1428    /// Returns the log dataset RID for the specified workspace if configured and accessible to the caller.
1429    #[endpoint(
1430        method = GET,
1431        path = "/catalog/v1/workspaces/{workspaceRid}/log-dataset",
1432        name = "getLogDatasetForWorkspace",
1433        produces = conjure_http::server::conjure::CollectionResponseSerializer
1434    )]
1435    async fn get_log_dataset_for_workspace(
1436        &self,
1437        #[auth]
1438        auth_: conjure_object::BearerToken,
1439        #[path(
1440            name = "workspaceRid",
1441            decoder = conjure_http::server::conjure::FromPlainDecoder,
1442            log_as = "workspaceRid"
1443        )]
1444        workspace_rid: conjure_object::ResourceIdentifier,
1445    ) -> Result<
1446        Option<conjure_object::ResourceIdentifier>,
1447        conjure_http::private::Error,
1448    >;
1449}
1450/// The Catalog Service provides the ability to query for information about Datasets that are stored in
1451/// the Nominal platform. A Dataset is the Nominal representation of data that has been uploaded to Nominal via
1452/// a file, primarily CSV.
1453#[conjure_http::conjure_endpoints(
1454    name = "CatalogService",
1455    use_legacy_error_serialization,
1456    local
1457)]
1458pub trait LocalAsyncCatalogService {
1459    #[endpoint(
1460        method = GET,
1461        path = "/catalog/v1/datasets/{datasetUuid}",
1462        name = "getEnrichedDataset",
1463        produces = conjure_http::server::StdResponseSerializer
1464    )]
1465    async fn get_enriched_dataset(
1466        &self,
1467        #[auth]
1468        auth_: conjure_object::BearerToken,
1469        #[path(
1470            name = "datasetUuid",
1471            decoder = conjure_http::server::conjure::FromPlainDecoder,
1472            log_as = "datasetUuid"
1473        )]
1474        dataset_uuid: conjure_object::Uuid,
1475    ) -> Result<
1476        super::super::super::super::objects::scout::catalog::EnrichedDataset,
1477        conjure_http::private::Error,
1478    >;
1479    #[endpoint(
1480        method = POST,
1481        path = "/catalog/v1/datasets/multiple",
1482        name = "getEnrichedDatasets",
1483        produces = conjure_http::server::conjure::CollectionResponseSerializer
1484    )]
1485    async fn get_enriched_datasets(
1486        &self,
1487        #[auth]
1488        auth_: conjure_object::BearerToken,
1489        #[body(
1490            deserializer = conjure_http::server::StdRequestDeserializer,
1491            log_as = "getDatasetsRequest"
1492        )]
1493        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
1494    ) -> Result<
1495        std::collections::BTreeSet<
1496            super::super::super::super::objects::scout::catalog::EnrichedDataset,
1497        >,
1498        conjure_http::private::Error,
1499    >;
1500    #[endpoint(
1501        method = GET,
1502        path = "/catalog/v1/datasets-simple/{datasetUuid}",
1503        name = "getDataset",
1504        produces = conjure_http::server::StdResponseSerializer
1505    )]
1506    async fn get_dataset(
1507        &self,
1508        #[auth]
1509        auth_: conjure_object::BearerToken,
1510        #[path(
1511            name = "datasetUuid",
1512            decoder = conjure_http::server::conjure::FromPlainDecoder,
1513            log_as = "datasetUuid"
1514        )]
1515        dataset_uuid: conjure_object::Uuid,
1516    ) -> Result<
1517        super::super::super::super::objects::scout::catalog::Dataset,
1518        conjure_http::private::Error,
1519    >;
1520    #[endpoint(
1521        method = POST,
1522        path = "/catalog/v1/datasets-simple/multiple",
1523        name = "getDatasets",
1524        produces = conjure_http::server::conjure::CollectionResponseSerializer
1525    )]
1526    async fn get_datasets(
1527        &self,
1528        #[auth]
1529        auth_: conjure_object::BearerToken,
1530        #[body(
1531            deserializer = conjure_http::server::StdRequestDeserializer,
1532            log_as = "getDatasetsRequest"
1533        )]
1534        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
1535    ) -> Result<
1536        std::collections::BTreeSet<
1537            super::super::super::super::objects::scout::catalog::Dataset,
1538        >,
1539        conjure_http::private::Error,
1540    >;
1541    /// Gets the subset of dataset RIDs that currently have external connection config attached.
1542    #[endpoint(
1543        method = POST,
1544        path = "/catalog/v1/datasets-simple/external-config",
1545        name = "getDatasetsWithExternalConnectionConfig",
1546        produces = conjure_http::server::conjure::CollectionResponseSerializer
1547    )]
1548    async fn get_datasets_with_external_connection_config(
1549        &self,
1550        #[auth]
1551        auth_: conjure_object::BearerToken,
1552        #[body(
1553            deserializer = conjure_http::server::StdRequestDeserializer,
1554            log_as = "getDatasetsRequest"
1555        )]
1556        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
1557    ) -> Result<
1558        std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
1559        conjure_http::private::Error,
1560    >;
1561    /// Registers or updates external connection configuration for an existing dataset.
1562    #[endpoint(
1563        method = POST,
1564        path = "/catalog/v1/datasets/external-config",
1565        name = "registerExternalConnectionConfig",
1566        produces = conjure_http::server::StdResponseSerializer
1567    )]
1568    async fn register_external_connection_config(
1569        &self,
1570        #[auth]
1571        auth_: conjure_object::BearerToken,
1572        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1573        request: super::super::super::super::objects::scout::catalog::RegisterExternalConnectionConfigRequest,
1574    ) -> Result<
1575        super::super::super::super::objects::scout::catalog::EnrichedDataset,
1576        conjure_http::private::Error,
1577    >;
1578    #[endpoint(
1579        method = GET,
1580        path = "/catalog/v1/dataset/{datasetRid}/file/{fileId}",
1581        name = "getDatasetFile",
1582        produces = conjure_http::server::StdResponseSerializer
1583    )]
1584    async fn get_dataset_file(
1585        &self,
1586        #[auth]
1587        auth_: conjure_object::BearerToken,
1588        #[path(
1589            name = "datasetRid",
1590            decoder = conjure_http::server::conjure::FromPlainDecoder,
1591            log_as = "datasetRid"
1592        )]
1593        dataset_rid: conjure_object::ResourceIdentifier,
1594        #[path(
1595            name = "fileId",
1596            decoder = conjure_http::server::conjure::FromPlainDecoder,
1597            log_as = "fileId",
1598            safe
1599        )]
1600        file_id: super::super::super::super::objects::datasource::DatasetFileId,
1601    ) -> Result<
1602        super::super::super::super::objects::scout::catalog::DatasetFile,
1603        conjure_http::private::Error,
1604    >;
1605    /// Returns dataset files for the given file IDs within a single dataset. Only returns files that
1606    /// exist and belong to the specified dataset. Useful for checking ingestion status of many files at once.
1607    #[endpoint(
1608        method = POST,
1609        path = "/catalog/v1/dataset-files/batchGet",
1610        name = "batchGetDatasetFiles",
1611        produces = conjure_http::server::conjure::CollectionResponseSerializer
1612    )]
1613    async fn batch_get_dataset_files(
1614        &self,
1615        #[auth]
1616        auth_: conjure_object::BearerToken,
1617        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1618        request: super::super::super::super::objects::scout::catalog::BatchGetDatasetFilesRequest,
1619    ) -> Result<
1620        std::collections::BTreeMap<
1621            super::super::super::super::objects::datasource::DatasetFileId,
1622            super::super::super::super::objects::scout::catalog::DatasetFile,
1623        >,
1624        conjure_http::private::Error,
1625    >;
1626    #[endpoint(
1627        method = GET,
1628        path = "/catalog/v1/ingest-job/{ingestJobRid}/files",
1629        name = "getDatasetFilesForJob",
1630        produces = conjure_http::server::StdResponseSerializer
1631    )]
1632    async fn get_dataset_files_for_job(
1633        &self,
1634        #[auth]
1635        auth_: conjure_object::BearerToken,
1636        #[path(
1637            name = "ingestJobRid",
1638            decoder = conjure_http::server::conjure::FromPlainDecoder,
1639            log_as = "ingestJobRid"
1640        )]
1641        ingest_job_rid: conjure_object::ResourceIdentifier,
1642        #[query(
1643            name = "nextPageToken",
1644            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
1645            log_as = "nextPageToken"
1646        )]
1647        next_page_token: Option<String>,
1648    ) -> Result<
1649        super::super::super::super::objects::scout::catalog::DatasetFilesPage,
1650        conjure_http::private::Error,
1651    >;
1652    #[endpoint(
1653        method = POST,
1654        path = "/catalog/v1/search-datasets-v2",
1655        name = "searchDatasets",
1656        produces = conjure_http::server::StdResponseSerializer
1657    )]
1658    async fn search_datasets(
1659        &self,
1660        #[auth]
1661        auth_: conjure_object::BearerToken,
1662        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1663        request: super::super::super::super::objects::scout::catalog::SearchDatasetsRequest,
1664    ) -> Result<
1665        super::super::super::super::objects::scout::catalog::SearchDatasetsResponse,
1666        conjure_http::private::Error,
1667    >;
1668    #[endpoint(
1669        method = PUT,
1670        path = "/catalog/v1/datasets/ingest-status-v2",
1671        name = "updateDatasetIngestStatusV2",
1672        produces = conjure_http::server::StdResponseSerializer
1673    )]
1674    async fn update_dataset_ingest_status_v2(
1675        &self,
1676        #[auth]
1677        auth_: conjure_object::BearerToken,
1678        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1679        details: super::super::super::super::objects::scout::catalog::UpdateIngestStatusV2,
1680    ) -> Result<
1681        super::super::super::super::objects::api::IngestStatusV2,
1682        conjure_http::private::Error,
1683    >;
1684    #[endpoint(
1685        method = GET,
1686        path = "/catalog/v1/datasets/{datasetRid}/ingest-progress-v2",
1687        name = "getIngestProgressV2",
1688        produces = conjure_http::server::StdResponseSerializer
1689    )]
1690    async fn get_ingest_progress_v2(
1691        &self,
1692        #[auth]
1693        auth_: conjure_object::BearerToken,
1694        #[path(
1695            name = "datasetRid",
1696            decoder = conjure_http::server::conjure::FromPlainDecoder,
1697            log_as = "datasetRid"
1698        )]
1699        dataset_rid: conjure_object::ResourceIdentifier,
1700    ) -> Result<
1701        super::super::super::super::objects::scout::catalog::IngestProgressV2,
1702        conjure_http::private::Error,
1703    >;
1704    #[endpoint(
1705        method = GET,
1706        path = "/catalog/v1/datasets/{dataset}/handle",
1707        name = "getHandleForDataset",
1708        produces = conjure_http::server::conjure::CollectionResponseSerializer
1709    )]
1710    async fn get_handle_for_dataset(
1711        &self,
1712        #[auth]
1713        auth_: conjure_object::BearerToken,
1714        #[path(
1715            name = "dataset",
1716            decoder = conjure_http::server::conjure::FromPlainDecoder
1717        )]
1718        dataset: conjure_object::Uuid,
1719    ) -> Result<
1720        Option<super::super::super::super::objects::scout::catalog::Handle>,
1721        conjure_http::private::Error,
1722    >;
1723    #[endpoint(
1724        method = POST,
1725        path = "/catalog/v1/datasets",
1726        name = "createDataset",
1727        produces = conjure_http::server::StdResponseSerializer
1728    )]
1729    async fn create_dataset(
1730        &self,
1731        #[auth]
1732        auth_: conjure_object::BearerToken,
1733        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1734        details: super::super::super::super::objects::scout::catalog::CreateDataset,
1735    ) -> Result<
1736        super::super::super::super::objects::scout::catalog::EnrichedDataset,
1737        conjure_http::private::Error,
1738    >;
1739    /// Creates a dataset if the s3 path does not exist, otherwise updates the dataset
1740    #[endpoint(
1741        method = POST,
1742        path = "/catalog/v1/datasets/create-or-update",
1743        name = "createOrUpdateDataset",
1744        produces = conjure_http::server::StdResponseSerializer
1745    )]
1746    async fn create_or_update_dataset(
1747        &self,
1748        #[auth]
1749        auth_: conjure_object::BearerToken,
1750        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1751        details: super::super::super::super::objects::scout::catalog::CreateDataset,
1752    ) -> Result<
1753        super::super::super::super::objects::scout::catalog::EnrichedDataset,
1754        conjure_http::private::Error,
1755    >;
1756    /// Creates a dataset with a specific UUID. This is useful for migrations and advanced use cases
1757    /// where the dataset UUID must be controlled by the caller. Throws a conflict error if a dataset
1758    /// with the specified UUID already exists. This endpoint is not intended for general use. Use /datasets instead to create a new dataset.
1759    #[endpoint(
1760        method = POST,
1761        path = "/catalog/v1/datasets/with-uuid",
1762        name = "createDatasetWithUuid",
1763        produces = conjure_http::server::StdResponseSerializer
1764    )]
1765    async fn create_dataset_with_uuid(
1766        &self,
1767        #[auth]
1768        auth_: conjure_object::BearerToken,
1769        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1770        request: super::super::super::super::objects::scout::catalog::CreateDatasetWithUuidRequest,
1771    ) -> Result<
1772        super::super::super::super::objects::scout::catalog::EnrichedDataset,
1773        conjure_http::private::Error,
1774    >;
1775    /// Adds a single file to an existing dataset.
1776    #[endpoint(
1777        method = POST,
1778        path = "/catalog/v1/datasets/{datasetRid}/add-file",
1779        name = "addFileToDataset",
1780        produces = conjure_http::server::StdResponseSerializer
1781    )]
1782    async fn add_file_to_dataset(
1783        &self,
1784        #[auth]
1785        auth_: conjure_object::BearerToken,
1786        #[path(
1787            name = "datasetRid",
1788            decoder = conjure_http::server::conjure::FromPlainDecoder,
1789            log_as = "datasetRid"
1790        )]
1791        dataset_rid: conjure_object::ResourceIdentifier,
1792        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1793        request: super::super::super::super::objects::scout::catalog::AddFileToDataset,
1794    ) -> Result<
1795        super::super::super::super::objects::scout::catalog::DatasetFile,
1796        conjure_http::private::Error,
1797    >;
1798    #[endpoint(
1799        method = GET,
1800        path = "/catalog/v1/datasets/{datasetRid}/files",
1801        name = "listDatasetFiles",
1802        produces = conjure_http::server::StdResponseSerializer
1803    )]
1804    async fn list_dataset_files(
1805        &self,
1806        #[auth]
1807        auth_: conjure_object::BearerToken,
1808        #[path(
1809            name = "datasetRid",
1810            decoder = conjure_http::server::conjure::FromPlainDecoder,
1811            log_as = "datasetRid"
1812        )]
1813        dataset_rid: conjure_object::ResourceIdentifier,
1814        #[query(
1815            name = "nextPageToken",
1816            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
1817            log_as = "nextPageToken"
1818        )]
1819        next_page_token: Option<String>,
1820    ) -> Result<
1821        super::super::super::super::objects::scout::catalog::DatasetFilesPage,
1822        conjure_http::private::Error,
1823    >;
1824    #[endpoint(
1825        method = POST,
1826        path = "/catalog/v1/search-dataset-files",
1827        name = "searchDatasetFiles",
1828        produces = conjure_http::server::StdResponseSerializer
1829    )]
1830    async fn search_dataset_files(
1831        &self,
1832        #[auth]
1833        auth_: conjure_object::BearerToken,
1834        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1835        request: super::super::super::super::objects::scout::catalog::SearchDatasetFilesRequest,
1836    ) -> Result<
1837        super::super::super::super::objects::scout::catalog::SearchDatasetFilesResponse,
1838        conjure_http::private::Error,
1839    >;
1840    #[endpoint(
1841        method = GET,
1842        path = "/catalog/v1/datasets/{datasetRid}/{fileId}/uri",
1843        name = "getDatasetFileUri",
1844        produces = conjure_http::server::StdResponseSerializer
1845    )]
1846    async fn get_dataset_file_uri(
1847        &self,
1848        #[auth]
1849        auth_: conjure_object::BearerToken,
1850        #[path(
1851            name = "datasetRid",
1852            decoder = conjure_http::server::conjure::FromPlainDecoder,
1853            log_as = "datasetRid"
1854        )]
1855        dataset_rid: conjure_object::ResourceIdentifier,
1856        #[path(
1857            name = "fileId",
1858            decoder = conjure_http::server::conjure::FromPlainDecoder,
1859            log_as = "fileId",
1860            safe
1861        )]
1862        file_id: super::super::super::super::objects::datasource::DatasetFileId,
1863    ) -> Result<
1864        super::super::super::super::objects::scout::catalog::DatasetFileUri,
1865        conjure_http::private::Error,
1866    >;
1867    #[endpoint(
1868        method = GET,
1869        path = "/catalog/v1/videos/{videoFileRid}/uri",
1870        name = "getVideoFileUri",
1871        produces = conjure_http::server::StdResponseSerializer
1872    )]
1873    async fn get_video_file_uri(
1874        &self,
1875        #[auth]
1876        auth_: conjure_object::BearerToken,
1877        #[path(
1878            name = "videoFileRid",
1879            decoder = conjure_http::server::conjure::FromPlainDecoder,
1880            log_as = "videoFileRid"
1881        )]
1882        video_file_rid: conjure_object::ResourceIdentifier,
1883    ) -> Result<
1884        super::super::super::super::objects::scout::catalog::VideoFileUri,
1885        conjure_http::private::Error,
1886    >;
1887    #[endpoint(
1888        method = GET,
1889        path = "/catalog/v1/datasets/{datasetRid}/{fileId}/origin-uris",
1890        name = "getOriginFileUris",
1891        produces = conjure_http::server::conjure::CollectionResponseSerializer
1892    )]
1893    async fn get_origin_file_uris(
1894        &self,
1895        #[auth]
1896        auth_: conjure_object::BearerToken,
1897        #[path(
1898            name = "datasetRid",
1899            decoder = conjure_http::server::conjure::FromPlainDecoder,
1900            log_as = "datasetRid"
1901        )]
1902        dataset_rid: conjure_object::ResourceIdentifier,
1903        #[path(
1904            name = "fileId",
1905            decoder = conjure_http::server::conjure::FromPlainDecoder,
1906            log_as = "fileId",
1907            safe
1908        )]
1909        file_id: super::super::super::super::objects::datasource::DatasetFileId,
1910    ) -> Result<
1911        Vec<super::super::super::super::objects::scout::catalog::OriginFileUri>,
1912        conjure_http::private::Error,
1913    >;
1914    #[endpoint(
1915        method = PUT,
1916        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/success",
1917        name = "markFileIngestSuccessful",
1918        produces = conjure_http::server::StdResponseSerializer
1919    )]
1920    async fn mark_file_ingest_successful(
1921        &self,
1922        #[auth]
1923        auth_: conjure_object::BearerToken,
1924        #[path(
1925            name = "datasetRid",
1926            decoder = conjure_http::server::conjure::FromPlainDecoder,
1927            log_as = "datasetRid"
1928        )]
1929        dataset_rid: conjure_object::ResourceIdentifier,
1930        #[path(
1931            name = "fileId",
1932            decoder = conjure_http::server::conjure::FromPlainDecoder,
1933            log_as = "fileId",
1934            safe
1935        )]
1936        file_id: super::super::super::super::objects::datasource::DatasetFileId,
1937        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
1938        request: super::super::super::super::objects::scout::catalog::MarkFileIngestSuccessful,
1939    ) -> Result<
1940        super::super::super::super::objects::scout::catalog::DatasetFile,
1941        conjure_http::private::Error,
1942    >;
1943    #[endpoint(
1944        method = PUT,
1945        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/error",
1946        name = "markFileIngestError",
1947        produces = conjure_http::server::StdResponseSerializer
1948    )]
1949    async fn mark_file_ingest_error(
1950        &self,
1951        #[auth]
1952        auth_: conjure_object::BearerToken,
1953        #[path(
1954            name = "datasetRid",
1955            decoder = conjure_http::server::conjure::FromPlainDecoder,
1956            log_as = "datasetRid"
1957        )]
1958        dataset_rid: conjure_object::ResourceIdentifier,
1959        #[path(
1960            name = "fileId",
1961            decoder = conjure_http::server::conjure::FromPlainDecoder,
1962            log_as = "fileId",
1963            safe
1964        )]
1965        file_id: super::super::super::super::objects::datasource::DatasetFileId,
1966        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1967        request: super::super::super::super::objects::scout::catalog::MarkFileIngestError,
1968    ) -> Result<
1969        super::super::super::super::objects::scout::catalog::DatasetFile,
1970        conjure_http::private::Error,
1971    >;
1972    /// Updates file-type-specific metadata for a dataset file. Currently used to update video segment metadata
1973    /// after video segmentation is complete.
1974    #[endpoint(
1975        method = PUT,
1976        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/metadata",
1977        name = "updateDatasetFileMetadata",
1978        produces = conjure_http::server::StdResponseSerializer
1979    )]
1980    async fn update_dataset_file_metadata(
1981        &self,
1982        #[auth]
1983        auth_: conjure_object::BearerToken,
1984        #[path(
1985            name = "datasetRid",
1986            decoder = conjure_http::server::conjure::FromPlainDecoder,
1987            log_as = "datasetRid"
1988        )]
1989        dataset_rid: conjure_object::ResourceIdentifier,
1990        #[path(
1991            name = "fileId",
1992            decoder = conjure_http::server::conjure::FromPlainDecoder,
1993            log_as = "fileId",
1994            safe
1995        )]
1996        file_id: super::super::super::super::objects::datasource::DatasetFileId,
1997        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1998        metadata: super::super::super::super::objects::scout::catalog::DatasetFileMetadata,
1999    ) -> Result<
2000        super::super::super::super::objects::scout::catalog::DatasetFile,
2001        conjure_http::private::Error,
2002    >;
2003    #[endpoint(
2004        method = PUT,
2005        path = "/catalog/v1/datasets/{datasetRid}",
2006        name = "updateDatasetMetadata",
2007        produces = conjure_http::server::StdResponseSerializer
2008    )]
2009    async fn update_dataset_metadata(
2010        &self,
2011        #[auth]
2012        auth_: conjure_object::BearerToken,
2013        #[path(
2014            name = "datasetRid",
2015            decoder = conjure_http::server::conjure::FromPlainDecoder,
2016            log_as = "datasetRid"
2017        )]
2018        dataset_rid: conjure_object::ResourceIdentifier,
2019        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
2020        request: super::super::super::super::objects::scout::catalog::UpdateDatasetMetadata,
2021    ) -> Result<
2022        super::super::super::super::objects::scout::catalog::EnrichedDataset,
2023        conjure_http::private::Error,
2024    >;
2025    /// Returns a versioned derived definition. If commit is omitted, returns the latest commit on main.
2026    #[endpoint(
2027        method = GET,
2028        path = "/catalog/v1/datasets/{datasetRid}/derived-definition",
2029        name = "getDatasetDerivedDefinition",
2030        produces = conjure_http::server::StdResponseSerializer
2031    )]
2032    async fn get_dataset_derived_definition(
2033        &self,
2034        #[auth]
2035        auth_: conjure_object::BearerToken,
2036        #[path(
2037            name = "datasetRid",
2038            decoder = conjure_http::server::conjure::FromPlainDecoder,
2039            log_as = "datasetRid"
2040        )]
2041        dataset_rid: conjure_object::ResourceIdentifier,
2042        #[query(
2043            name = "commit",
2044            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
2045            safe
2046        )]
2047        commit: Option<
2048            super::super::super::super::objects::scout::versioning::api::CommitId,
2049        >,
2050    ) -> Result<
2051        super::super::super::super::objects::scout::catalog::DerivedDefinition,
2052        conjure_http::private::Error,
2053    >;
2054    /// Replaces the current derived definition by creating a permanent commit on main.
2055    /// Throws if the dataset is not derived, if referenced datasets are unauthorized, or if latestCommit is stale.
2056    #[endpoint(
2057        method = POST,
2058        path = "/catalog/v1/datasets/{datasetRid}/derived-definition/commit",
2059        name = "commitDerivedDefinition",
2060        produces = conjure_http::server::StdResponseSerializer
2061    )]
2062    async fn commit_derived_definition(
2063        &self,
2064        #[auth]
2065        auth_: conjure_object::BearerToken,
2066        #[path(
2067            name = "datasetRid",
2068            decoder = conjure_http::server::conjure::FromPlainDecoder,
2069            log_as = "datasetRid"
2070        )]
2071        dataset_rid: conjure_object::ResourceIdentifier,
2072        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
2073        request: super::super::super::super::objects::scout::catalog::CommitDerivedDefinitionRequest,
2074    ) -> Result<
2075        super::super::super::super::objects::scout::catalog::DerivedDefinition,
2076        conjure_http::private::Error,
2077    >;
2078    /// Update the bounds for a dataset without updating bounds of files within the dataset. If the
2079    /// current bounds of the dataset are not set, then the bounds of the request will be used. Otherwise,
2080    /// the bounds will be min(current start, request start), max(current end, request end).
2081    #[endpoint(
2082        method = PUT,
2083        path = "/catalog/v1/datasets/{rid}/bounds-from-streaming",
2084        name = "updateGlobalDatasetBounds",
2085        produces = conjure_http::server::StdResponseSerializer
2086    )]
2087    async fn update_global_dataset_bounds(
2088        &self,
2089        #[auth]
2090        auth_: conjure_object::BearerToken,
2091        #[path(name = "rid", decoder = conjure_http::server::conjure::FromPlainDecoder)]
2092        rid: conjure_object::ResourceIdentifier,
2093        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
2094        request: super::super::super::super::objects::scout::catalog::UpdateBoundsRequest,
2095    ) -> Result<
2096        super::super::super::super::objects::scout::catalog::Dataset,
2097        conjure_http::private::Error,
2098    >;
2099    /// Archives a dataset, which will hide it from search results unless the includeArchived flag is set to true. The
2100    /// dataset can still be directly accessed by its UUID/rid.
2101    #[endpoint(
2102        method = POST,
2103        path = "/catalog/v1/datasets/{datasetRid}/archive",
2104        name = "archiveDataset"
2105    )]
2106    async fn archive_dataset(
2107        &self,
2108        #[auth]
2109        auth_: conjure_object::BearerToken,
2110        #[path(
2111            name = "datasetRid",
2112            decoder = conjure_http::server::conjure::FromPlainDecoder,
2113            log_as = "datasetRid"
2114        )]
2115        dataset_rid: conjure_object::ResourceIdentifier,
2116    ) -> Result<(), conjure_http::private::Error>;
2117    /// Undoes the archiving of a dataset.
2118    #[endpoint(
2119        method = POST,
2120        path = "/catalog/v1/datasets/{datasetRid}/unarchive",
2121        name = "unarchiveDataset"
2122    )]
2123    async fn unarchive_dataset(
2124        &self,
2125        #[auth]
2126        auth_: conjure_object::BearerToken,
2127        #[path(
2128            name = "datasetRid",
2129            decoder = conjure_http::server::conjure::FromPlainDecoder,
2130            log_as = "datasetRid"
2131        )]
2132        dataset_rid: conjure_object::ResourceIdentifier,
2133    ) -> Result<(), conjure_http::private::Error>;
2134    #[endpoint(
2135        method = GET,
2136        path = "/catalog/v1/datasets/all-properties-labels",
2137        name = "getAllPropertiesAndLabels",
2138        produces = conjure_http::server::StdResponseSerializer
2139    )]
2140    async fn get_all_properties_and_labels(
2141        &self,
2142        #[auth]
2143        auth_: conjure_object::BearerToken,
2144        #[query(
2145            name = "workspaces",
2146            decoder = conjure_http::server::conjure::FromPlainSeqDecoder<_>
2147        )]
2148        workspaces: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
2149    ) -> Result<
2150        super::super::super::super::objects::scout::catalog::AllPropertiesAndLabelsResponse,
2151        conjure_http::private::Error,
2152    >;
2153    /// Returns the log dataset RID for the specified workspace if configured and accessible to the caller.
2154    #[endpoint(
2155        method = GET,
2156        path = "/catalog/v1/workspaces/{workspaceRid}/log-dataset",
2157        name = "getLogDatasetForWorkspace",
2158        produces = conjure_http::server::conjure::CollectionResponseSerializer
2159    )]
2160    async fn get_log_dataset_for_workspace(
2161        &self,
2162        #[auth]
2163        auth_: conjure_object::BearerToken,
2164        #[path(
2165            name = "workspaceRid",
2166            decoder = conjure_http::server::conjure::FromPlainDecoder,
2167            log_as = "workspaceRid"
2168        )]
2169        workspace_rid: conjure_object::ResourceIdentifier,
2170    ) -> Result<
2171        Option<conjure_object::ResourceIdentifier>,
2172        conjure_http::private::Error,
2173    >;
2174}
nominal_api/conjure/endpoints/scout/catalog/catalog_service.rs

nominal_api/conjure/endpoints/scout/catalog/
catalog_service.rs
