nominal-api 0.1239.0

use conjure_http::endpoint;
/// The Catalog Service provides the ability to query for information about Datasets that are stored in
/// the Nominal platform. A Dataset is the Nominal representation of data that has been uploaded to Nominal via
/// a file, primarily CSV.
#[conjure_http::conjure_endpoints(
    name = "CatalogService",
    use_legacy_error_serialization
)]
pub trait CatalogService {
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetUuid}",
        name = "getEnrichedDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn get_enriched_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetUuid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetUuid"
        )]
        dataset_uuid: conjure_object::Uuid,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/multiple",
        name = "getEnrichedDatasets",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    fn get_enriched_datasets(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "getDatasetsRequest"
        )]
        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::scout::catalog::EnrichedDataset,
        >,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets-simple/{datasetUuid}",
        name = "getDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn get_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetUuid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetUuid"
        )]
        dataset_uuid: conjure_object::Uuid,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::Dataset,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets-simple/multiple",
        name = "getDatasets",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    fn get_datasets(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "getDatasetsRequest"
        )]
        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::scout::catalog::Dataset,
        >,
        conjure_http::private::Error,
    >;
    /// Gets the subset of dataset RIDs that currently have external connection config attached.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets-simple/external-config",
        name = "getDatasetsWithExternalConnectionConfig",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    fn get_datasets_with_external_connection_config(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "getDatasetsRequest"
        )]
        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::api::rids::DatasetRid,
        >,
        conjure_http::private::Error,
    >;
    /// Registers or updates external connection configuration for an existing dataset.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/external-config",
        name = "registerExternalConnectionConfig",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn register_external_connection_config(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::RegisterExternalConnectionConfigRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/dataset/{datasetRid}/file/{fileId}",
        name = "getDatasetFile",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn get_dataset_file(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    /// Returns dataset files for the given file IDs within a single dataset. Only returns files that
    /// exist and belong to the specified dataset. Useful for checking ingestion status of many files at once.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/dataset-files/batchGet",
        name = "batchGetDatasetFiles",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    fn batch_get_dataset_files(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::BatchGetDatasetFilesRequest,
    ) -> Result<
        std::collections::BTreeMap<
            super::super::super::super::objects::datasource::DatasetFileId,
            super::super::super::super::objects::scout::catalog::DatasetFile,
        >,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/ingest-job/{ingestJobRid}/files",
        name = "getDatasetFilesForJob",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn get_dataset_files_for_job(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "ingestJobRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "ingestJobRid"
        )]
        ingest_job_rid: conjure_object::ResourceIdentifier,
        #[query(
            name = "nextPageToken",
            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
            log_as = "nextPageToken"
        )]
        next_page_token: Option<super::super::super::super::objects::api::Token>,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFilesPage,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/search-datasets-v2",
        name = "searchDatasets",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn search_datasets(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::SearchDatasetsRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::SearchDatasetsResponse,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/ingest-status-v2",
        name = "updateDatasetIngestStatusV2",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn update_dataset_ingest_status_v2(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        details: super::super::super::super::objects::scout::catalog::UpdateIngestStatusV2,
    ) -> Result<
        super::super::super::super::objects::api::IngestStatusV2,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetRid}/ingest-progress-v2",
        name = "getIngestProgressV2",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn get_ingest_progress_v2(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::IngestProgressV2,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{dataset}/handle",
        name = "getHandleForDataset",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    fn get_handle_for_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "dataset",
            decoder = conjure_http::server::conjure::FromPlainDecoder
        )]
        dataset: conjure_object::Uuid,
    ) -> Result<
        Option<super::super::super::super::objects::scout::catalog::Handle>,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets",
        name = "createDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn create_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        details: super::super::super::super::objects::scout::catalog::CreateDataset,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    /// Creates a dataset if the s3 path does not exist, otherwise updates the dataset
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/create-or-update",
        name = "createOrUpdateDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn create_or_update_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        details: super::super::super::super::objects::scout::catalog::CreateDataset,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    /// Creates a dataset with a specific UUID. This is useful for migrations and advanced use cases
    /// where the dataset UUID must be controlled by the caller. Throws a conflict error if a dataset
    /// with the specified UUID already exists. This endpoint is not intended for general use. Use /datasets instead to create a new dataset.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/with-uuid",
        name = "createDatasetWithUuid",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn create_dataset_with_uuid(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::CreateDatasetWithUuidRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    /// Adds a single file to an existing dataset.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/{datasetRid}/add-file",
        name = "addFileToDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn add_file_to_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::AddFileToDataset,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetRid}/files",
        name = "listDatasetFiles",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn list_dataset_files(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[query(
            name = "nextPageToken",
            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
            log_as = "nextPageToken"
        )]
        next_page_token: Option<super::super::super::super::objects::api::Token>,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFilesPage,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/search-dataset-files",
        name = "searchDatasetFiles",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn search_dataset_files(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::SearchDatasetFilesRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::SearchDatasetFilesResponse,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetRid}/{fileId}/uri",
        name = "getDatasetFileUri",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn get_dataset_file_uri(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid",
            safe
        )]
        dataset_rid: super::super::super::super::objects::api::rids::DatasetRid,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFileUri,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/videos/{videoFileRid}/uri",
        name = "getVideoFileUri",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn get_video_file_uri(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid",
            safe
        )]
        video_file_rid: super::super::super::super::objects::api::rids::VideoFileRid,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::VideoFileUri,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetRid}/{fileId}/origin-uris",
        name = "getOriginFileUris",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    fn get_origin_file_uris(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid",
            safe
        )]
        dataset_rid: super::super::super::super::objects::api::rids::DatasetRid,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
    ) -> Result<
        Vec<super::super::super::super::objects::scout::catalog::OriginFileUri>,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/success",
        name = "markFileIngestSuccessful",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn mark_file_ingest_successful(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
        request: super::super::super::super::objects::scout::catalog::MarkFileIngestSuccessful,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/error",
        name = "markFileIngestError",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn mark_file_ingest_error(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::MarkFileIngestError,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    /// Updates file-type-specific metadata for a dataset file. Currently used to update video segment metadata
    /// after video segmentation is complete.
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/metadata",
        name = "updateDatasetFileMetadata",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn update_dataset_file_metadata(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid",
            safe
        )]
        dataset_rid: super::super::super::super::objects::api::rids::DatasetRid,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        metadata: super::super::super::super::objects::scout::catalog::DatasetFileMetadata,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{datasetRid}",
        name = "updateDatasetMetadata",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn update_dataset_metadata(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::UpdateDatasetMetadata,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    /// Update the bounds for a dataset without updating bounds of files within the dataset. If the
    /// current bounds of the dataset are not set, then the bounds of the request will be used. Otherwise,
    /// the bounds will be min(current start, request start), max(current end, request end).
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{rid}/bounds-from-streaming",
        name = "updateGlobalDatasetBounds",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn update_global_dataset_bounds(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(name = "rid", decoder = conjure_http::server::conjure::FromPlainDecoder)]
        rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
        request: super::super::super::super::objects::scout::catalog::UpdateBoundsRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::Dataset,
        conjure_http::private::Error,
    >;
    /// Archives a dataset, which will hide it from search results unless the includeArchived flag is set to true. The
    /// dataset can still be directly accessed by its UUID/rid.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/{datasetRid}/archive",
        name = "archiveDataset"
    )]
    fn archive_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    /// Undoes the archiving of a dataset.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/{datasetRid}/unarchive",
        name = "unarchiveDataset"
    )]
    fn unarchive_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/all-properties-labels",
        name = "getAllPropertiesAndLabels",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn get_all_properties_and_labels(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[query(
            name = "workspaces",
            decoder = conjure_http::server::conjure::FromPlainSeqDecoder<_>,
            safe
        )]
        workspaces: std::collections::BTreeSet<
            super::super::super::super::objects::api::rids::WorkspaceRid,
        >,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::AllPropertiesAndLabelsResponse,
        conjure_http::private::Error,
    >;
    /// Returns the log dataset RID for the specified workspace if configured and accessible to the caller.
    #[endpoint(
        method = GET,
        path = "/catalog/v1/workspaces/{workspaceRid}/log-dataset",
        name = "getLogDatasetForWorkspace",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    fn get_log_dataset_for_workspace(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "workspaceRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "workspaceRid",
            safe
        )]
        workspace_rid: super::super::super::super::objects::api::rids::WorkspaceRid,
    ) -> Result<
        Option<super::super::super::super::objects::api::rids::DatasetRid>,
        conjure_http::private::Error,
    >;
}
/// The Catalog Service provides the ability to query for information about Datasets that are stored in
/// the Nominal platform. A Dataset is the Nominal representation of data that has been uploaded to Nominal via
/// a file, primarily CSV.
#[conjure_http::conjure_endpoints(
    name = "CatalogService",
    use_legacy_error_serialization
)]
pub trait AsyncCatalogService {
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetUuid}",
        name = "getEnrichedDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_enriched_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetUuid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetUuid"
        )]
        dataset_uuid: conjure_object::Uuid,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/multiple",
        name = "getEnrichedDatasets",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn get_enriched_datasets(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "getDatasetsRequest"
        )]
        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::scout::catalog::EnrichedDataset,
        >,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets-simple/{datasetUuid}",
        name = "getDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetUuid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetUuid"
        )]
        dataset_uuid: conjure_object::Uuid,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::Dataset,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets-simple/multiple",
        name = "getDatasets",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn get_datasets(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "getDatasetsRequest"
        )]
        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::scout::catalog::Dataset,
        >,
        conjure_http::private::Error,
    >;
    /// Gets the subset of dataset RIDs that currently have external connection config attached.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets-simple/external-config",
        name = "getDatasetsWithExternalConnectionConfig",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn get_datasets_with_external_connection_config(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "getDatasetsRequest"
        )]
        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::api::rids::DatasetRid,
        >,
        conjure_http::private::Error,
    >;
    /// Registers or updates external connection configuration for an existing dataset.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/external-config",
        name = "registerExternalConnectionConfig",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn register_external_connection_config(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::RegisterExternalConnectionConfigRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/dataset/{datasetRid}/file/{fileId}",
        name = "getDatasetFile",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_dataset_file(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    /// Returns dataset files for the given file IDs within a single dataset. Only returns files that
    /// exist and belong to the specified dataset. Useful for checking ingestion status of many files at once.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/dataset-files/batchGet",
        name = "batchGetDatasetFiles",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn batch_get_dataset_files(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::BatchGetDatasetFilesRequest,
    ) -> Result<
        std::collections::BTreeMap<
            super::super::super::super::objects::datasource::DatasetFileId,
            super::super::super::super::objects::scout::catalog::DatasetFile,
        >,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/ingest-job/{ingestJobRid}/files",
        name = "getDatasetFilesForJob",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_dataset_files_for_job(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "ingestJobRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "ingestJobRid"
        )]
        ingest_job_rid: conjure_object::ResourceIdentifier,
        #[query(
            name = "nextPageToken",
            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
            log_as = "nextPageToken"
        )]
        next_page_token: Option<super::super::super::super::objects::api::Token>,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFilesPage,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/search-datasets-v2",
        name = "searchDatasets",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn search_datasets(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::SearchDatasetsRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::SearchDatasetsResponse,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/ingest-status-v2",
        name = "updateDatasetIngestStatusV2",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn update_dataset_ingest_status_v2(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        details: super::super::super::super::objects::scout::catalog::UpdateIngestStatusV2,
    ) -> Result<
        super::super::super::super::objects::api::IngestStatusV2,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetRid}/ingest-progress-v2",
        name = "getIngestProgressV2",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_ingest_progress_v2(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::IngestProgressV2,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{dataset}/handle",
        name = "getHandleForDataset",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn get_handle_for_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "dataset",
            decoder = conjure_http::server::conjure::FromPlainDecoder
        )]
        dataset: conjure_object::Uuid,
    ) -> Result<
        Option<super::super::super::super::objects::scout::catalog::Handle>,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets",
        name = "createDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn create_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        details: super::super::super::super::objects::scout::catalog::CreateDataset,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    /// Creates a dataset if the s3 path does not exist, otherwise updates the dataset
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/create-or-update",
        name = "createOrUpdateDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn create_or_update_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        details: super::super::super::super::objects::scout::catalog::CreateDataset,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    /// Creates a dataset with a specific UUID. This is useful for migrations and advanced use cases
    /// where the dataset UUID must be controlled by the caller. Throws a conflict error if a dataset
    /// with the specified UUID already exists. This endpoint is not intended for general use. Use /datasets instead to create a new dataset.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/with-uuid",
        name = "createDatasetWithUuid",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn create_dataset_with_uuid(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::CreateDatasetWithUuidRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    /// Adds a single file to an existing dataset.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/{datasetRid}/add-file",
        name = "addFileToDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn add_file_to_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::AddFileToDataset,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetRid}/files",
        name = "listDatasetFiles",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn list_dataset_files(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[query(
            name = "nextPageToken",
            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
            log_as = "nextPageToken"
        )]
        next_page_token: Option<super::super::super::super::objects::api::Token>,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFilesPage,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/search-dataset-files",
        name = "searchDatasetFiles",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn search_dataset_files(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::SearchDatasetFilesRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::SearchDatasetFilesResponse,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetRid}/{fileId}/uri",
        name = "getDatasetFileUri",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_dataset_file_uri(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid",
            safe
        )]
        dataset_rid: super::super::super::super::objects::api::rids::DatasetRid,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFileUri,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/videos/{videoFileRid}/uri",
        name = "getVideoFileUri",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_video_file_uri(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid",
            safe
        )]
        video_file_rid: super::super::super::super::objects::api::rids::VideoFileRid,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::VideoFileUri,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetRid}/{fileId}/origin-uris",
        name = "getOriginFileUris",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn get_origin_file_uris(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid",
            safe
        )]
        dataset_rid: super::super::super::super::objects::api::rids::DatasetRid,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
    ) -> Result<
        Vec<super::super::super::super::objects::scout::catalog::OriginFileUri>,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/success",
        name = "markFileIngestSuccessful",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn mark_file_ingest_successful(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
        request: super::super::super::super::objects::scout::catalog::MarkFileIngestSuccessful,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/error",
        name = "markFileIngestError",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn mark_file_ingest_error(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::MarkFileIngestError,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    /// Updates file-type-specific metadata for a dataset file. Currently used to update video segment metadata
    /// after video segmentation is complete.
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/metadata",
        name = "updateDatasetFileMetadata",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn update_dataset_file_metadata(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid",
            safe
        )]
        dataset_rid: super::super::super::super::objects::api::rids::DatasetRid,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        metadata: super::super::super::super::objects::scout::catalog::DatasetFileMetadata,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{datasetRid}",
        name = "updateDatasetMetadata",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn update_dataset_metadata(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::UpdateDatasetMetadata,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    /// Update the bounds for a dataset without updating bounds of files within the dataset. If the
    /// current bounds of the dataset are not set, then the bounds of the request will be used. Otherwise,
    /// the bounds will be min(current start, request start), max(current end, request end).
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{rid}/bounds-from-streaming",
        name = "updateGlobalDatasetBounds",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn update_global_dataset_bounds(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(name = "rid", decoder = conjure_http::server::conjure::FromPlainDecoder)]
        rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
        request: super::super::super::super::objects::scout::catalog::UpdateBoundsRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::Dataset,
        conjure_http::private::Error,
    >;
    /// Archives a dataset, which will hide it from search results unless the includeArchived flag is set to true. The
    /// dataset can still be directly accessed by its UUID/rid.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/{datasetRid}/archive",
        name = "archiveDataset"
    )]
    async fn archive_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    /// Undoes the archiving of a dataset.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/{datasetRid}/unarchive",
        name = "unarchiveDataset"
    )]
    async fn unarchive_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/all-properties-labels",
        name = "getAllPropertiesAndLabels",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_all_properties_and_labels(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[query(
            name = "workspaces",
            decoder = conjure_http::server::conjure::FromPlainSeqDecoder<_>,
            safe
        )]
        workspaces: std::collections::BTreeSet<
            super::super::super::super::objects::api::rids::WorkspaceRid,
        >,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::AllPropertiesAndLabelsResponse,
        conjure_http::private::Error,
    >;
    /// Returns the log dataset RID for the specified workspace if configured and accessible to the caller.
    #[endpoint(
        method = GET,
        path = "/catalog/v1/workspaces/{workspaceRid}/log-dataset",
        name = "getLogDatasetForWorkspace",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn get_log_dataset_for_workspace(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "workspaceRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "workspaceRid",
            safe
        )]
        workspace_rid: super::super::super::super::objects::api::rids::WorkspaceRid,
    ) -> Result<
        Option<super::super::super::super::objects::api::rids::DatasetRid>,
        conjure_http::private::Error,
    >;
}
/// The Catalog Service provides the ability to query for information about Datasets that are stored in
/// the Nominal platform. A Dataset is the Nominal representation of data that has been uploaded to Nominal via
/// a file, primarily CSV.
#[conjure_http::conjure_endpoints(
    name = "CatalogService",
    use_legacy_error_serialization,
    local
)]
pub trait LocalAsyncCatalogService {
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetUuid}",
        name = "getEnrichedDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_enriched_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetUuid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetUuid"
        )]
        dataset_uuid: conjure_object::Uuid,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/multiple",
        name = "getEnrichedDatasets",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn get_enriched_datasets(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "getDatasetsRequest"
        )]
        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::scout::catalog::EnrichedDataset,
        >,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets-simple/{datasetUuid}",
        name = "getDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetUuid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetUuid"
        )]
        dataset_uuid: conjure_object::Uuid,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::Dataset,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets-simple/multiple",
        name = "getDatasets",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn get_datasets(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "getDatasetsRequest"
        )]
        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::scout::catalog::Dataset,
        >,
        conjure_http::private::Error,
    >;
    /// Gets the subset of dataset RIDs that currently have external connection config attached.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets-simple/external-config",
        name = "getDatasetsWithExternalConnectionConfig",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn get_datasets_with_external_connection_config(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "getDatasetsRequest"
        )]
        get_datasets_request: super::super::super::super::objects::scout::catalog::GetDatasetsRequest,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::api::rids::DatasetRid,
        >,
        conjure_http::private::Error,
    >;
    /// Registers or updates external connection configuration for an existing dataset.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/external-config",
        name = "registerExternalConnectionConfig",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn register_external_connection_config(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::RegisterExternalConnectionConfigRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/dataset/{datasetRid}/file/{fileId}",
        name = "getDatasetFile",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_dataset_file(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    /// Returns dataset files for the given file IDs within a single dataset. Only returns files that
    /// exist and belong to the specified dataset. Useful for checking ingestion status of many files at once.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/dataset-files/batchGet",
        name = "batchGetDatasetFiles",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn batch_get_dataset_files(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::BatchGetDatasetFilesRequest,
    ) -> Result<
        std::collections::BTreeMap<
            super::super::super::super::objects::datasource::DatasetFileId,
            super::super::super::super::objects::scout::catalog::DatasetFile,
        >,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/ingest-job/{ingestJobRid}/files",
        name = "getDatasetFilesForJob",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_dataset_files_for_job(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "ingestJobRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "ingestJobRid"
        )]
        ingest_job_rid: conjure_object::ResourceIdentifier,
        #[query(
            name = "nextPageToken",
            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
            log_as = "nextPageToken"
        )]
        next_page_token: Option<super::super::super::super::objects::api::Token>,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFilesPage,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/search-datasets-v2",
        name = "searchDatasets",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn search_datasets(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::SearchDatasetsRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::SearchDatasetsResponse,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/ingest-status-v2",
        name = "updateDatasetIngestStatusV2",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn update_dataset_ingest_status_v2(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        details: super::super::super::super::objects::scout::catalog::UpdateIngestStatusV2,
    ) -> Result<
        super::super::super::super::objects::api::IngestStatusV2,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetRid}/ingest-progress-v2",
        name = "getIngestProgressV2",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_ingest_progress_v2(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::IngestProgressV2,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{dataset}/handle",
        name = "getHandleForDataset",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn get_handle_for_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "dataset",
            decoder = conjure_http::server::conjure::FromPlainDecoder
        )]
        dataset: conjure_object::Uuid,
    ) -> Result<
        Option<super::super::super::super::objects::scout::catalog::Handle>,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets",
        name = "createDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn create_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        details: super::super::super::super::objects::scout::catalog::CreateDataset,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    /// Creates a dataset if the s3 path does not exist, otherwise updates the dataset
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/create-or-update",
        name = "createOrUpdateDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn create_or_update_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        details: super::super::super::super::objects::scout::catalog::CreateDataset,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    /// Creates a dataset with a specific UUID. This is useful for migrations and advanced use cases
    /// where the dataset UUID must be controlled by the caller. Throws a conflict error if a dataset
    /// with the specified UUID already exists. This endpoint is not intended for general use. Use /datasets instead to create a new dataset.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/with-uuid",
        name = "createDatasetWithUuid",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn create_dataset_with_uuid(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::CreateDatasetWithUuidRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    /// Adds a single file to an existing dataset.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/{datasetRid}/add-file",
        name = "addFileToDataset",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn add_file_to_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::AddFileToDataset,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetRid}/files",
        name = "listDatasetFiles",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn list_dataset_files(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[query(
            name = "nextPageToken",
            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
            log_as = "nextPageToken"
        )]
        next_page_token: Option<super::super::super::super::objects::api::Token>,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFilesPage,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/catalog/v1/search-dataset-files",
        name = "searchDatasetFiles",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn search_dataset_files(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::SearchDatasetFilesRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::SearchDatasetFilesResponse,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetRid}/{fileId}/uri",
        name = "getDatasetFileUri",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_dataset_file_uri(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid",
            safe
        )]
        dataset_rid: super::super::super::super::objects::api::rids::DatasetRid,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFileUri,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/videos/{videoFileRid}/uri",
        name = "getVideoFileUri",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_video_file_uri(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid",
            safe
        )]
        video_file_rid: super::super::super::super::objects::api::rids::VideoFileRid,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::VideoFileUri,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/{datasetRid}/{fileId}/origin-uris",
        name = "getOriginFileUris",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn get_origin_file_uris(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid",
            safe
        )]
        dataset_rid: super::super::super::super::objects::api::rids::DatasetRid,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
    ) -> Result<
        Vec<super::super::super::super::objects::scout::catalog::OriginFileUri>,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/success",
        name = "markFileIngestSuccessful",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn mark_file_ingest_successful(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
        request: super::super::super::super::objects::scout::catalog::MarkFileIngestSuccessful,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/error",
        name = "markFileIngestError",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn mark_file_ingest_error(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::MarkFileIngestError,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    /// Updates file-type-specific metadata for a dataset file. Currently used to update video segment metadata
    /// after video segmentation is complete.
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{datasetRid}/file/{fileId}/metadata",
        name = "updateDatasetFileMetadata",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn update_dataset_file_metadata(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid",
            safe
        )]
        dataset_rid: super::super::super::super::objects::api::rids::DatasetRid,
        #[path(
            name = "fileId",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "fileId",
            safe
        )]
        file_id: super::super::super::super::objects::datasource::DatasetFileId,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        metadata: super::super::super::super::objects::scout::catalog::DatasetFileMetadata,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::DatasetFile,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{datasetRid}",
        name = "updateDatasetMetadata",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn update_dataset_metadata(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::catalog::UpdateDatasetMetadata,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::EnrichedDataset,
        conjure_http::private::Error,
    >;
    /// Update the bounds for a dataset without updating bounds of files within the dataset. If the
    /// current bounds of the dataset are not set, then the bounds of the request will be used. Otherwise,
    /// the bounds will be min(current start, request start), max(current end, request end).
    #[endpoint(
        method = PUT,
        path = "/catalog/v1/datasets/{rid}/bounds-from-streaming",
        name = "updateGlobalDatasetBounds",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn update_global_dataset_bounds(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(name = "rid", decoder = conjure_http::server::conjure::FromPlainDecoder)]
        rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
        request: super::super::super::super::objects::scout::catalog::UpdateBoundsRequest,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::Dataset,
        conjure_http::private::Error,
    >;
    /// Archives a dataset, which will hide it from search results unless the includeArchived flag is set to true. The
    /// dataset can still be directly accessed by its UUID/rid.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/{datasetRid}/archive",
        name = "archiveDataset"
    )]
    async fn archive_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    /// Undoes the archiving of a dataset.
    #[endpoint(
        method = POST,
        path = "/catalog/v1/datasets/{datasetRid}/unarchive",
        name = "unarchiveDataset"
    )]
    async fn unarchive_dataset(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "datasetRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "datasetRid"
        )]
        dataset_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    #[endpoint(
        method = GET,
        path = "/catalog/v1/datasets/all-properties-labels",
        name = "getAllPropertiesAndLabels",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_all_properties_and_labels(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[query(
            name = "workspaces",
            decoder = conjure_http::server::conjure::FromPlainSeqDecoder<_>,
            safe
        )]
        workspaces: std::collections::BTreeSet<
            super::super::super::super::objects::api::rids::WorkspaceRid,
        >,
    ) -> Result<
        super::super::super::super::objects::scout::catalog::AllPropertiesAndLabelsResponse,
        conjure_http::private::Error,
    >;
    /// Returns the log dataset RID for the specified workspace if configured and accessible to the caller.
    #[endpoint(
        method = GET,
        path = "/catalog/v1/workspaces/{workspaceRid}/log-dataset",
        name = "getLogDatasetForWorkspace",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn get_log_dataset_for_workspace(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "workspaceRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "workspaceRid",
            safe
        )]
        workspace_rid: super::super::super::super::objects::api::rids::WorkspaceRid,
    ) -> Result<
        Option<super::super::super::super::objects::api::rids::DatasetRid>,
        conjure_http::private::Error,
    >;
}