use conjure_http::endpoint;
/// The video service manages individual video files and their metadata.
#[conjure_http::conjure_endpoints(
    name = "VideoFileService",
    use_legacy_error_serialization
)]
pub trait VideoFileService<#[response_writer] O> {
    ///The body type returned by the `get_playlist` method.
    type GetPlaylistBody: conjure_http::server::WriteBody<O> + 'static;
    /// Create and persist a video file entity with the given metadata
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files",
        name = "create",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn create(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::video::api::CreateVideoFileRequest,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::VideoFile,
        conjure_http::private::Error,
    >;
    /// Returns video file metadata associated with a video file RID.
    #[endpoint(
        method = GET,
        path = "/video-files/v1/video-files/{videoFileRid}",
        name = "get",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn get(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::VideoFile,
        conjure_http::private::Error,
    >;
    /// Returns all video files and their metadata associated with the given RIDs
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files/batchGet",
        name = "batchGet",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    fn batch_get(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "videoFileRids"
        )]
        video_file_rids: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::scout::video::api::VideoFile,
        >,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files/list-files-in-video",
        name = "listFilesInVideo",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    fn list_files_in_video(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "videoRid"
        )]
        video_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::scout::video::api::VideoFile,
        >,
        conjure_http::private::Error,
    >;
    /// Returns a paginated list of all video files and their metadata associated with the given video RID.
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files/list-files-in-video-paginated",
        name = "listFilesInVideoPaginated",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn list_files_in_video_paginated(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "videoRid"
        )]
        video_rid: super::super::super::super::objects::scout::video::api::ListFilesInVideoRequest,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::ListFilesInVideoResponse,
        conjure_http::private::Error,
    >;
    /// Updates the metadata for a video file associated with the given RID.
    #[endpoint(
        method = PUT,
        path = "/video-files/v1/video-files/{videoFileRid}",
        name = "update",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn update(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::video::api::UpdateVideoFileRequest,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::VideoFile,
        conjure_http::private::Error,
    >;
    /// Updates metadata for multiple video files in a single video.
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files/batch-update",
        name = "batchUpdate",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn batch_update(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::video::api::BatchUpdateVideoFilesRequest,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::BatchUpdateVideoFilesResponse,
        conjure_http::private::Error,
    >;
    /// Permanently deletes a video file and all associated segments from the database.
    /// This operation cannot be undone.
    #[endpoint(
        method = DELETE,
        path = "/video-files/v1/video-files/{videoFileRid}",
        name = "delete"
    )]
    fn delete(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    #[endpoint(
        method = PUT,
        path = "/video-files/v1/video-files/{videoFileRid}/archive",
        name = "archive"
    )]
    fn archive(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    #[endpoint(
        method = PUT,
        path = "/video-files/v1/video-files/{videoFileRid}/unarchive",
        name = "unarchive"
    )]
    fn unarchive(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    /// Get the latest ingest status for a given video file by RID.
    #[endpoint(
        method = GET,
        path = "/video-files/v1/video-files/{videoFileRid}/ingest-status",
        name = "getIngestStatus",
        produces = conjure_http::server::StdResponseSerializer
    )]
    fn get_ingest_status(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::GetIngestStatusResponse,
        conjure_http::private::Error,
    >;
    /// Get the latest ingest status for a set of given video files by RID.
    #[endpoint(
        method = POST,
        path = "/video-files/v1/videos/batch-get-ingest-status",
        name = "batchGetIngestStatus",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    fn batch_get_ingest_status(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "videoFileRids"
        )]
        video_file_rids: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
    ) -> Result<
        std::collections::BTreeMap<
            conjure_object::ResourceIdentifier,
            super::super::super::super::objects::scout::video::api::VideoFileIngestStatus,
        >,
        conjure_http::private::Error,
    >;
    /// Update the latest ingest status for a given video file by RID.
    #[endpoint(
        method = PUT,
        path = "/video-files/v1/videos/{videoFileRid}/ingest-status",
        name = "updateIngestStatus"
    )]
    fn update_ingest_status(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::video::api::UpdateIngestStatusRequest,
    ) -> Result<(), conjure_http::private::Error>;
    /// Returns the min and max absolute and media timestamps for each segment in a video file.
    /// To be used during frame-timestamp mapping when playing back videos.
    #[endpoint(
        method = GET,
        path = "/video-files/v1/video-files/{videoFileRid}/segment-summaries",
        name = "getSegmentSummaries",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    fn get_segment_summaries(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        Vec<super::super::super::super::objects::scout::video::api::SegmentSummary>,
        conjure_http::private::Error,
    >;
    /// Generate an HLS playlist for a video file with the given RID to enable playback.
    /// The HLS playlist will contain links to all of the video segments in the video in sequential order.
    #[endpoint(
        method = GET,
        path = "/video-files/v1/video-files/{videoFileRid}/playlist",
        name = "getPlaylist",
        produces = conjure_http::server::conjure::BinaryResponseSerializer
    )]
    fn get_playlist(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<Self::GetPlaylistBody, conjure_http::private::Error>;
}
/// The video service manages individual video files and their metadata.
#[conjure_http::conjure_endpoints(
    name = "VideoFileService",
    use_legacy_error_serialization
)]
pub trait AsyncVideoFileService<#[response_writer] O> {
    ///The body type returned by the `get_playlist` method.
    type GetPlaylistBody: conjure_http::server::AsyncWriteBody<O> + 'static + Send;
    /// Create and persist a video file entity with the given metadata
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files",
        name = "create",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn create(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::video::api::CreateVideoFileRequest,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::VideoFile,
        conjure_http::private::Error,
    >;
    /// Returns video file metadata associated with a video file RID.
    #[endpoint(
        method = GET,
        path = "/video-files/v1/video-files/{videoFileRid}",
        name = "get",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::VideoFile,
        conjure_http::private::Error,
    >;
    /// Returns all video files and their metadata associated with the given RIDs
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files/batchGet",
        name = "batchGet",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn batch_get(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "videoFileRids"
        )]
        video_file_rids: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::scout::video::api::VideoFile,
        >,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files/list-files-in-video",
        name = "listFilesInVideo",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn list_files_in_video(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "videoRid"
        )]
        video_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::scout::video::api::VideoFile,
        >,
        conjure_http::private::Error,
    >;
    /// Returns a paginated list of all video files and their metadata associated with the given video RID.
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files/list-files-in-video-paginated",
        name = "listFilesInVideoPaginated",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn list_files_in_video_paginated(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "videoRid"
        )]
        video_rid: super::super::super::super::objects::scout::video::api::ListFilesInVideoRequest,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::ListFilesInVideoResponse,
        conjure_http::private::Error,
    >;
    /// Updates the metadata for a video file associated with the given RID.
    #[endpoint(
        method = PUT,
        path = "/video-files/v1/video-files/{videoFileRid}",
        name = "update",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn update(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::video::api::UpdateVideoFileRequest,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::VideoFile,
        conjure_http::private::Error,
    >;
    /// Updates metadata for multiple video files in a single video.
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files/batch-update",
        name = "batchUpdate",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn batch_update(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::video::api::BatchUpdateVideoFilesRequest,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::BatchUpdateVideoFilesResponse,
        conjure_http::private::Error,
    >;
    /// Permanently deletes a video file and all associated segments from the database.
    /// This operation cannot be undone.
    #[endpoint(
        method = DELETE,
        path = "/video-files/v1/video-files/{videoFileRid}",
        name = "delete"
    )]
    async fn delete(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    #[endpoint(
        method = PUT,
        path = "/video-files/v1/video-files/{videoFileRid}/archive",
        name = "archive"
    )]
    async fn archive(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    #[endpoint(
        method = PUT,
        path = "/video-files/v1/video-files/{videoFileRid}/unarchive",
        name = "unarchive"
    )]
    async fn unarchive(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    /// Get the latest ingest status for a given video file by RID.
    #[endpoint(
        method = GET,
        path = "/video-files/v1/video-files/{videoFileRid}/ingest-status",
        name = "getIngestStatus",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_ingest_status(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::GetIngestStatusResponse,
        conjure_http::private::Error,
    >;
    /// Get the latest ingest status for a set of given video files by RID.
    #[endpoint(
        method = POST,
        path = "/video-files/v1/videos/batch-get-ingest-status",
        name = "batchGetIngestStatus",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn batch_get_ingest_status(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "videoFileRids"
        )]
        video_file_rids: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
    ) -> Result<
        std::collections::BTreeMap<
            conjure_object::ResourceIdentifier,
            super::super::super::super::objects::scout::video::api::VideoFileIngestStatus,
        >,
        conjure_http::private::Error,
    >;
    /// Update the latest ingest status for a given video file by RID.
    #[endpoint(
        method = PUT,
        path = "/video-files/v1/videos/{videoFileRid}/ingest-status",
        name = "updateIngestStatus"
    )]
    async fn update_ingest_status(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::video::api::UpdateIngestStatusRequest,
    ) -> Result<(), conjure_http::private::Error>;
    /// Returns the min and max absolute and media timestamps for each segment in a video file.
    /// To be used during frame-timestamp mapping when playing back videos.
    #[endpoint(
        method = GET,
        path = "/video-files/v1/video-files/{videoFileRid}/segment-summaries",
        name = "getSegmentSummaries",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn get_segment_summaries(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        Vec<super::super::super::super::objects::scout::video::api::SegmentSummary>,
        conjure_http::private::Error,
    >;
    /// Generate an HLS playlist for a video file with the given RID to enable playback.
    /// The HLS playlist will contain links to all of the video segments in the video in sequential order.
    #[endpoint(
        method = GET,
        path = "/video-files/v1/video-files/{videoFileRid}/playlist",
        name = "getPlaylist",
        produces = conjure_http::server::conjure::BinaryResponseSerializer
    )]
    async fn get_playlist(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<Self::GetPlaylistBody, conjure_http::private::Error>;
}
/// The video service manages individual video files and their metadata.
#[conjure_http::conjure_endpoints(
    name = "VideoFileService",
    use_legacy_error_serialization,
    local
)]
pub trait LocalAsyncVideoFileService<#[response_writer] O> {
    ///The body type returned by the `get_playlist` method.
    type GetPlaylistBody: conjure_http::server::LocalAsyncWriteBody<O> + 'static;
    /// Create and persist a video file entity with the given metadata
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files",
        name = "create",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn create(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::video::api::CreateVideoFileRequest,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::VideoFile,
        conjure_http::private::Error,
    >;
    /// Returns video file metadata associated with a video file RID.
    #[endpoint(
        method = GET,
        path = "/video-files/v1/video-files/{videoFileRid}",
        name = "get",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::VideoFile,
        conjure_http::private::Error,
    >;
    /// Returns all video files and their metadata associated with the given RIDs
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files/batchGet",
        name = "batchGet",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn batch_get(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "videoFileRids"
        )]
        video_file_rids: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::scout::video::api::VideoFile,
        >,
        conjure_http::private::Error,
    >;
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files/list-files-in-video",
        name = "listFilesInVideo",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn list_files_in_video(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "videoRid"
        )]
        video_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        std::collections::BTreeSet<
            super::super::super::super::objects::scout::video::api::VideoFile,
        >,
        conjure_http::private::Error,
    >;
    /// Returns a paginated list of all video files and their metadata associated with the given video RID.
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files/list-files-in-video-paginated",
        name = "listFilesInVideoPaginated",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn list_files_in_video_paginated(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "videoRid"
        )]
        video_rid: super::super::super::super::objects::scout::video::api::ListFilesInVideoRequest,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::ListFilesInVideoResponse,
        conjure_http::private::Error,
    >;
    /// Updates the metadata for a video file associated with the given RID.
    #[endpoint(
        method = PUT,
        path = "/video-files/v1/video-files/{videoFileRid}",
        name = "update",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn update(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::video::api::UpdateVideoFileRequest,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::VideoFile,
        conjure_http::private::Error,
    >;
    /// Updates metadata for multiple video files in a single video.
    #[endpoint(
        method = POST,
        path = "/video-files/v1/video-files/batch-update",
        name = "batchUpdate",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn batch_update(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::video::api::BatchUpdateVideoFilesRequest,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::BatchUpdateVideoFilesResponse,
        conjure_http::private::Error,
    >;
    /// Permanently deletes a video file and all associated segments from the database.
    /// This operation cannot be undone.
    #[endpoint(
        method = DELETE,
        path = "/video-files/v1/video-files/{videoFileRid}",
        name = "delete"
    )]
    async fn delete(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    #[endpoint(
        method = PUT,
        path = "/video-files/v1/video-files/{videoFileRid}/archive",
        name = "archive"
    )]
    async fn archive(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    #[endpoint(
        method = PUT,
        path = "/video-files/v1/video-files/{videoFileRid}/unarchive",
        name = "unarchive"
    )]
    async fn unarchive(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<(), conjure_http::private::Error>;
    /// Get the latest ingest status for a given video file by RID.
    #[endpoint(
        method = GET,
        path = "/video-files/v1/video-files/{videoFileRid}/ingest-status",
        name = "getIngestStatus",
        produces = conjure_http::server::StdResponseSerializer
    )]
    async fn get_ingest_status(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        super::super::super::super::objects::scout::video::api::GetIngestStatusResponse,
        conjure_http::private::Error,
    >;
    /// Get the latest ingest status for a set of given video files by RID.
    #[endpoint(
        method = POST,
        path = "/video-files/v1/videos/batch-get-ingest-status",
        name = "batchGetIngestStatus",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn batch_get_ingest_status(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[body(
            deserializer = conjure_http::server::StdRequestDeserializer,
            log_as = "videoFileRids"
        )]
        video_file_rids: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
    ) -> Result<
        std::collections::BTreeMap<
            conjure_object::ResourceIdentifier,
            super::super::super::super::objects::scout::video::api::VideoFileIngestStatus,
        >,
        conjure_http::private::Error,
    >;
    /// Update the latest ingest status for a given video file by RID.
    #[endpoint(
        method = PUT,
        path = "/video-files/v1/videos/{videoFileRid}/ingest-status",
        name = "updateIngestStatus"
    )]
    async fn update_ingest_status(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
        request: super::super::super::super::objects::scout::video::api::UpdateIngestStatusRequest,
    ) -> Result<(), conjure_http::private::Error>;
    /// Returns the min and max absolute and media timestamps for each segment in a video file.
    /// To be used during frame-timestamp mapping when playing back videos.
    #[endpoint(
        method = GET,
        path = "/video-files/v1/video-files/{videoFileRid}/segment-summaries",
        name = "getSegmentSummaries",
        produces = conjure_http::server::conjure::CollectionResponseSerializer
    )]
    async fn get_segment_summaries(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<
        Vec<super::super::super::super::objects::scout::video::api::SegmentSummary>,
        conjure_http::private::Error,
    >;
    /// Generate an HLS playlist for a video file with the given RID to enable playback.
    /// The HLS playlist will contain links to all of the video segments in the video in sequential order.
    #[endpoint(
        method = GET,
        path = "/video-files/v1/video-files/{videoFileRid}/playlist",
        name = "getPlaylist",
        produces = conjure_http::server::conjure::BinaryResponseSerializer
    )]
    async fn get_playlist(
        &self,
        #[auth]
        auth_: conjure_object::BearerToken,
        #[path(
            name = "videoFileRid",
            decoder = conjure_http::server::conjure::FromPlainDecoder,
            log_as = "videoFileRid"
        )]
        video_file_rid: conjure_object::ResourceIdentifier,
    ) -> Result<Self::GetPlaylistBody, conjure_http::private::Error>;
}
