nominal_api_conjure/conjure/endpoints/scout/video/
video_file_service.rs

1use conjure_http::endpoint;
2/// The video service manages individual video files and their metadata.
3#[conjure_http::conjure_endpoints(
4    name = "VideoFileService",
5    use_legacy_error_serialization
6)]
7pub trait VideoFileService<#[response_writer] O> {
8    ///The body type returned by the `get_playlist` method.
9    type GetPlaylistBody: conjure_http::server::WriteBody<O> + 'static;
10    /// Create and persist a video file entity with the given metadata
11    #[endpoint(
12        method = POST,
13        path = "/video-files/v1/video-files",
14        name = "create",
15        produces = conjure_http::server::StdResponseSerializer
16    )]
17    fn create(
18        &self,
19        #[auth]
20        auth_: conjure_object::BearerToken,
21        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
22        request: super::super::super::super::objects::scout::video::api::CreateVideoFileRequest,
23    ) -> Result<
24        super::super::super::super::objects::scout::video::api::VideoFile,
25        conjure_http::private::Error,
26    >;
27    /// Returns video file metadata associated with a video file RID.
28    #[endpoint(
29        method = GET,
30        path = "/video-files/v1/video-files/{videoFileRid}",
31        name = "get",
32        produces = conjure_http::server::StdResponseSerializer
33    )]
34    fn get(
35        &self,
36        #[auth]
37        auth_: conjure_object::BearerToken,
38        #[path(
39            name = "videoFileRid",
40            decoder = conjure_http::server::conjure::FromPlainDecoder,
41            log_as = "videoFileRid"
42        )]
43        video_file_rid: conjure_object::ResourceIdentifier,
44    ) -> Result<
45        super::super::super::super::objects::scout::video::api::VideoFile,
46        conjure_http::private::Error,
47    >;
48    /// Returns all video files and their metadata associated with the given RIDs
49    #[endpoint(
50        method = POST,
51        path = "/video-files/v1/video-files/batchGet",
52        name = "batchGet",
53        produces = conjure_http::server::conjure::CollectionResponseSerializer
54    )]
55    fn batch_get(
56        &self,
57        #[auth]
58        auth_: conjure_object::BearerToken,
59        #[body(
60            deserializer = conjure_http::server::StdRequestDeserializer,
61            log_as = "videoFileRids"
62        )]
63        video_file_rids: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
64    ) -> Result<
65        std::collections::BTreeSet<
66            super::super::super::super::objects::scout::video::api::VideoFile,
67        >,
68        conjure_http::private::Error,
69    >;
70    #[endpoint(
71        method = POST,
72        path = "/video-files/v1/video-files/list-files-in-video",
73        name = "listFilesInVideo",
74        produces = conjure_http::server::conjure::CollectionResponseSerializer
75    )]
76    fn list_files_in_video(
77        &self,
78        #[auth]
79        auth_: conjure_object::BearerToken,
80        #[body(
81            deserializer = conjure_http::server::StdRequestDeserializer,
82            log_as = "videoRid"
83        )]
84        video_rid: conjure_object::ResourceIdentifier,
85    ) -> Result<
86        std::collections::BTreeSet<
87            super::super::super::super::objects::scout::video::api::VideoFile,
88        >,
89        conjure_http::private::Error,
90    >;
91    /// Returns a paginated list of all video files and their metadata associated with the given video RID.
92    #[endpoint(
93        method = POST,
94        path = "/video-files/v1/video-files/list-files-in-video-paginated",
95        name = "listFilesInVideoPaginated",
96        produces = conjure_http::server::StdResponseSerializer
97    )]
98    fn list_files_in_video_paginated(
99        &self,
100        #[auth]
101        auth_: conjure_object::BearerToken,
102        #[body(
103            deserializer = conjure_http::server::StdRequestDeserializer,
104            log_as = "videoRid"
105        )]
106        video_rid: super::super::super::super::objects::scout::video::api::ListFilesInVideoRequest,
107    ) -> Result<
108        super::super::super::super::objects::scout::video::api::ListFilesInVideoResponse,
109        conjure_http::private::Error,
110    >;
111    /// Updates the metadata for a video file associated with the given RID.
112    #[endpoint(
113        method = PUT,
114        path = "/video-files/v1/video-files/{videoFileRid}",
115        name = "update",
116        produces = conjure_http::server::StdResponseSerializer
117    )]
118    fn update(
119        &self,
120        #[auth]
121        auth_: conjure_object::BearerToken,
122        #[path(
123            name = "videoFileRid",
124            decoder = conjure_http::server::conjure::FromPlainDecoder,
125            log_as = "videoFileRid"
126        )]
127        video_file_rid: conjure_object::ResourceIdentifier,
128        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
129        request: super::super::super::super::objects::scout::video::api::UpdateVideoFileRequest,
130    ) -> Result<
131        super::super::super::super::objects::scout::video::api::VideoFile,
132        conjure_http::private::Error,
133    >;
134    /// Updates metadata for multiple video files in a single video.
135    #[endpoint(
136        method = POST,
137        path = "/video-files/v1/video-files/batch-update",
138        name = "batchUpdate",
139        produces = conjure_http::server::StdResponseSerializer
140    )]
141    fn batch_update(
142        &self,
143        #[auth]
144        auth_: conjure_object::BearerToken,
145        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
146        request: super::super::super::super::objects::scout::video::api::BatchUpdateVideoFilesRequest,
147    ) -> Result<
148        super::super::super::super::objects::scout::video::api::BatchUpdateVideoFilesResponse,
149        conjure_http::private::Error,
150    >;
151    /// Permanently deletes a video file and all associated segments from the database.
152    /// This operation cannot be undone.
153    #[endpoint(
154        method = DELETE,
155        path = "/video-files/v1/video-files/{videoFileRid}",
156        name = "delete"
157    )]
158    fn delete(
159        &self,
160        #[auth]
161        auth_: conjure_object::BearerToken,
162        #[path(
163            name = "videoFileRid",
164            decoder = conjure_http::server::conjure::FromPlainDecoder,
165            log_as = "videoFileRid"
166        )]
167        video_file_rid: conjure_object::ResourceIdentifier,
168    ) -> Result<(), conjure_http::private::Error>;
169    #[endpoint(
170        method = PUT,
171        path = "/video-files/v1/video-files/{videoFileRid}/archive",
172        name = "archive"
173    )]
174    fn archive(
175        &self,
176        #[auth]
177        auth_: conjure_object::BearerToken,
178        #[path(
179            name = "videoFileRid",
180            decoder = conjure_http::server::conjure::FromPlainDecoder,
181            log_as = "videoFileRid"
182        )]
183        video_file_rid: conjure_object::ResourceIdentifier,
184    ) -> Result<(), conjure_http::private::Error>;
185    #[endpoint(
186        method = PUT,
187        path = "/video-files/v1/video-files/{videoFileRid}/unarchive",
188        name = "unarchive"
189    )]
190    fn unarchive(
191        &self,
192        #[auth]
193        auth_: conjure_object::BearerToken,
194        #[path(
195            name = "videoFileRid",
196            decoder = conjure_http::server::conjure::FromPlainDecoder,
197            log_as = "videoFileRid"
198        )]
199        video_file_rid: conjure_object::ResourceIdentifier,
200    ) -> Result<(), conjure_http::private::Error>;
201    /// Get the latest ingest status for a given video file by RID.
202    #[endpoint(
203        method = GET,
204        path = "/video-files/v1/video-files/{videoFileRid}/ingest-status",
205        name = "getIngestStatus",
206        produces = conjure_http::server::StdResponseSerializer
207    )]
208    fn get_ingest_status(
209        &self,
210        #[auth]
211        auth_: conjure_object::BearerToken,
212        #[path(
213            name = "videoFileRid",
214            decoder = conjure_http::server::conjure::FromPlainDecoder,
215            log_as = "videoFileRid"
216        )]
217        video_file_rid: conjure_object::ResourceIdentifier,
218    ) -> Result<
219        super::super::super::super::objects::scout::video::api::GetIngestStatusResponse,
220        conjure_http::private::Error,
221    >;
222    /// Get the latest ingest status for a set of given video files by RID.
223    #[endpoint(
224        method = POST,
225        path = "/video-files/v1/videos/batch-get-ingest-status",
226        name = "batchGetIngestStatus",
227        produces = conjure_http::server::conjure::CollectionResponseSerializer
228    )]
229    fn batch_get_ingest_status(
230        &self,
231        #[auth]
232        auth_: conjure_object::BearerToken,
233        #[body(
234            deserializer = conjure_http::server::StdRequestDeserializer,
235            log_as = "videoFileRids"
236        )]
237        video_file_rids: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
238    ) -> Result<
239        std::collections::BTreeMap<
240            conjure_object::ResourceIdentifier,
241            super::super::super::super::objects::scout::video::api::VideoFileIngestStatus,
242        >,
243        conjure_http::private::Error,
244    >;
245    /// Update the latest ingest status for a given video file by RID.
246    #[endpoint(
247        method = PUT,
248        path = "/video-files/v1/videos/{videoFileRid}/ingest-status",
249        name = "updateIngestStatus"
250    )]
251    fn update_ingest_status(
252        &self,
253        #[auth]
254        auth_: conjure_object::BearerToken,
255        #[path(
256            name = "videoFileRid",
257            decoder = conjure_http::server::conjure::FromPlainDecoder,
258            log_as = "videoFileRid"
259        )]
260        video_file_rid: conjure_object::ResourceIdentifier,
261        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
262        request: super::super::super::super::objects::scout::video::api::UpdateIngestStatusRequest,
263    ) -> Result<(), conjure_http::private::Error>;
264    /// Returns the min and max absolute and media timestamps for each segment in a video file.
265    /// To be used during frame-timestamp mapping when playing back videos.
266    #[endpoint(
267        method = GET,
268        path = "/video-files/v1/video-files/{videoFileRid}/segment-summaries",
269        name = "getSegmentSummaries",
270        produces = conjure_http::server::conjure::CollectionResponseSerializer
271    )]
272    fn get_segment_summaries(
273        &self,
274        #[auth]
275        auth_: conjure_object::BearerToken,
276        #[path(
277            name = "videoFileRid",
278            decoder = conjure_http::server::conjure::FromPlainDecoder,
279            log_as = "videoFileRid"
280        )]
281        video_file_rid: conjure_object::ResourceIdentifier,
282    ) -> Result<
283        Vec<super::super::super::super::objects::scout::video::api::SegmentSummary>,
284        conjure_http::private::Error,
285    >;
286    /// Generate an HLS playlist for a video file with the given RID to enable playback.
287    /// The HLS playlist will contain links to all of the video segments in the video in sequential order.
288    #[endpoint(
289        method = GET,
290        path = "/video-files/v1/video-files/{videoFileRid}/playlist",
291        name = "getPlaylist",
292        produces = conjure_http::server::conjure::BinaryResponseSerializer
293    )]
294    fn get_playlist(
295        &self,
296        #[auth]
297        auth_: conjure_object::BearerToken,
298        #[path(
299            name = "videoFileRid",
300            decoder = conjure_http::server::conjure::FromPlainDecoder,
301            log_as = "videoFileRid"
302        )]
303        video_file_rid: conjure_object::ResourceIdentifier,
304    ) -> Result<Self::GetPlaylistBody, conjure_http::private::Error>;
305}
306/// The video service manages individual video files and their metadata.
307#[conjure_http::conjure_endpoints(
308    name = "VideoFileService",
309    use_legacy_error_serialization
310)]
311pub trait AsyncVideoFileService<#[response_writer] O> {
312    ///The body type returned by the `get_playlist` method.
313    type GetPlaylistBody: conjure_http::server::AsyncWriteBody<O> + 'static + Send;
314    /// Create and persist a video file entity with the given metadata
315    #[endpoint(
316        method = POST,
317        path = "/video-files/v1/video-files",
318        name = "create",
319        produces = conjure_http::server::StdResponseSerializer
320    )]
321    async fn create(
322        &self,
323        #[auth]
324        auth_: conjure_object::BearerToken,
325        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
326        request: super::super::super::super::objects::scout::video::api::CreateVideoFileRequest,
327    ) -> Result<
328        super::super::super::super::objects::scout::video::api::VideoFile,
329        conjure_http::private::Error,
330    >;
331    /// Returns video file metadata associated with a video file RID.
332    #[endpoint(
333        method = GET,
334        path = "/video-files/v1/video-files/{videoFileRid}",
335        name = "get",
336        produces = conjure_http::server::StdResponseSerializer
337    )]
338    async fn get(
339        &self,
340        #[auth]
341        auth_: conjure_object::BearerToken,
342        #[path(
343            name = "videoFileRid",
344            decoder = conjure_http::server::conjure::FromPlainDecoder,
345            log_as = "videoFileRid"
346        )]
347        video_file_rid: conjure_object::ResourceIdentifier,
348    ) -> Result<
349        super::super::super::super::objects::scout::video::api::VideoFile,
350        conjure_http::private::Error,
351    >;
352    /// Returns all video files and their metadata associated with the given RIDs
353    #[endpoint(
354        method = POST,
355        path = "/video-files/v1/video-files/batchGet",
356        name = "batchGet",
357        produces = conjure_http::server::conjure::CollectionResponseSerializer
358    )]
359    async fn batch_get(
360        &self,
361        #[auth]
362        auth_: conjure_object::BearerToken,
363        #[body(
364            deserializer = conjure_http::server::StdRequestDeserializer,
365            log_as = "videoFileRids"
366        )]
367        video_file_rids: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
368    ) -> Result<
369        std::collections::BTreeSet<
370            super::super::super::super::objects::scout::video::api::VideoFile,
371        >,
372        conjure_http::private::Error,
373    >;
374    #[endpoint(
375        method = POST,
376        path = "/video-files/v1/video-files/list-files-in-video",
377        name = "listFilesInVideo",
378        produces = conjure_http::server::conjure::CollectionResponseSerializer
379    )]
380    async fn list_files_in_video(
381        &self,
382        #[auth]
383        auth_: conjure_object::BearerToken,
384        #[body(
385            deserializer = conjure_http::server::StdRequestDeserializer,
386            log_as = "videoRid"
387        )]
388        video_rid: conjure_object::ResourceIdentifier,
389    ) -> Result<
390        std::collections::BTreeSet<
391            super::super::super::super::objects::scout::video::api::VideoFile,
392        >,
393        conjure_http::private::Error,
394    >;
395    /// Returns a paginated list of all video files and their metadata associated with the given video RID.
396    #[endpoint(
397        method = POST,
398        path = "/video-files/v1/video-files/list-files-in-video-paginated",
399        name = "listFilesInVideoPaginated",
400        produces = conjure_http::server::StdResponseSerializer
401    )]
402    async fn list_files_in_video_paginated(
403        &self,
404        #[auth]
405        auth_: conjure_object::BearerToken,
406        #[body(
407            deserializer = conjure_http::server::StdRequestDeserializer,
408            log_as = "videoRid"
409        )]
410        video_rid: super::super::super::super::objects::scout::video::api::ListFilesInVideoRequest,
411    ) -> Result<
412        super::super::super::super::objects::scout::video::api::ListFilesInVideoResponse,
413        conjure_http::private::Error,
414    >;
415    /// Updates the metadata for a video file associated with the given RID.
416    #[endpoint(
417        method = PUT,
418        path = "/video-files/v1/video-files/{videoFileRid}",
419        name = "update",
420        produces = conjure_http::server::StdResponseSerializer
421    )]
422    async fn update(
423        &self,
424        #[auth]
425        auth_: conjure_object::BearerToken,
426        #[path(
427            name = "videoFileRid",
428            decoder = conjure_http::server::conjure::FromPlainDecoder,
429            log_as = "videoFileRid"
430        )]
431        video_file_rid: conjure_object::ResourceIdentifier,
432        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
433        request: super::super::super::super::objects::scout::video::api::UpdateVideoFileRequest,
434    ) -> Result<
435        super::super::super::super::objects::scout::video::api::VideoFile,
436        conjure_http::private::Error,
437    >;
438    /// Updates metadata for multiple video files in a single video.
439    #[endpoint(
440        method = POST,
441        path = "/video-files/v1/video-files/batch-update",
442        name = "batchUpdate",
443        produces = conjure_http::server::StdResponseSerializer
444    )]
445    async fn batch_update(
446        &self,
447        #[auth]
448        auth_: conjure_object::BearerToken,
449        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
450        request: super::super::super::super::objects::scout::video::api::BatchUpdateVideoFilesRequest,
451    ) -> Result<
452        super::super::super::super::objects::scout::video::api::BatchUpdateVideoFilesResponse,
453        conjure_http::private::Error,
454    >;
455    /// Permanently deletes a video file and all associated segments from the database.
456    /// This operation cannot be undone.
457    #[endpoint(
458        method = DELETE,
459        path = "/video-files/v1/video-files/{videoFileRid}",
460        name = "delete"
461    )]
462    async fn delete(
463        &self,
464        #[auth]
465        auth_: conjure_object::BearerToken,
466        #[path(
467            name = "videoFileRid",
468            decoder = conjure_http::server::conjure::FromPlainDecoder,
469            log_as = "videoFileRid"
470        )]
471        video_file_rid: conjure_object::ResourceIdentifier,
472    ) -> Result<(), conjure_http::private::Error>;
473    #[endpoint(
474        method = PUT,
475        path = "/video-files/v1/video-files/{videoFileRid}/archive",
476        name = "archive"
477    )]
478    async fn archive(
479        &self,
480        #[auth]
481        auth_: conjure_object::BearerToken,
482        #[path(
483            name = "videoFileRid",
484            decoder = conjure_http::server::conjure::FromPlainDecoder,
485            log_as = "videoFileRid"
486        )]
487        video_file_rid: conjure_object::ResourceIdentifier,
488    ) -> Result<(), conjure_http::private::Error>;
489    #[endpoint(
490        method = PUT,
491        path = "/video-files/v1/video-files/{videoFileRid}/unarchive",
492        name = "unarchive"
493    )]
494    async fn unarchive(
495        &self,
496        #[auth]
497        auth_: conjure_object::BearerToken,
498        #[path(
499            name = "videoFileRid",
500            decoder = conjure_http::server::conjure::FromPlainDecoder,
501            log_as = "videoFileRid"
502        )]
503        video_file_rid: conjure_object::ResourceIdentifier,
504    ) -> Result<(), conjure_http::private::Error>;
505    /// Get the latest ingest status for a given video file by RID.
506    #[endpoint(
507        method = GET,
508        path = "/video-files/v1/video-files/{videoFileRid}/ingest-status",
509        name = "getIngestStatus",
510        produces = conjure_http::server::StdResponseSerializer
511    )]
512    async fn get_ingest_status(
513        &self,
514        #[auth]
515        auth_: conjure_object::BearerToken,
516        #[path(
517            name = "videoFileRid",
518            decoder = conjure_http::server::conjure::FromPlainDecoder,
519            log_as = "videoFileRid"
520        )]
521        video_file_rid: conjure_object::ResourceIdentifier,
522    ) -> Result<
523        super::super::super::super::objects::scout::video::api::GetIngestStatusResponse,
524        conjure_http::private::Error,
525    >;
526    /// Get the latest ingest status for a set of given video files by RID.
527    #[endpoint(
528        method = POST,
529        path = "/video-files/v1/videos/batch-get-ingest-status",
530        name = "batchGetIngestStatus",
531        produces = conjure_http::server::conjure::CollectionResponseSerializer
532    )]
533    async fn batch_get_ingest_status(
534        &self,
535        #[auth]
536        auth_: conjure_object::BearerToken,
537        #[body(
538            deserializer = conjure_http::server::StdRequestDeserializer,
539            log_as = "videoFileRids"
540        )]
541        video_file_rids: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
542    ) -> Result<
543        std::collections::BTreeMap<
544            conjure_object::ResourceIdentifier,
545            super::super::super::super::objects::scout::video::api::VideoFileIngestStatus,
546        >,
547        conjure_http::private::Error,
548    >;
549    /// Update the latest ingest status for a given video file by RID.
550    #[endpoint(
551        method = PUT,
552        path = "/video-files/v1/videos/{videoFileRid}/ingest-status",
553        name = "updateIngestStatus"
554    )]
555    async fn update_ingest_status(
556        &self,
557        #[auth]
558        auth_: conjure_object::BearerToken,
559        #[path(
560            name = "videoFileRid",
561            decoder = conjure_http::server::conjure::FromPlainDecoder,
562            log_as = "videoFileRid"
563        )]
564        video_file_rid: conjure_object::ResourceIdentifier,
565        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
566        request: super::super::super::super::objects::scout::video::api::UpdateIngestStatusRequest,
567    ) -> Result<(), conjure_http::private::Error>;
568    /// Returns the min and max absolute and media timestamps for each segment in a video file.
569    /// To be used during frame-timestamp mapping when playing back videos.
570    #[endpoint(
571        method = GET,
572        path = "/video-files/v1/video-files/{videoFileRid}/segment-summaries",
573        name = "getSegmentSummaries",
574        produces = conjure_http::server::conjure::CollectionResponseSerializer
575    )]
576    async fn get_segment_summaries(
577        &self,
578        #[auth]
579        auth_: conjure_object::BearerToken,
580        #[path(
581            name = "videoFileRid",
582            decoder = conjure_http::server::conjure::FromPlainDecoder,
583            log_as = "videoFileRid"
584        )]
585        video_file_rid: conjure_object::ResourceIdentifier,
586    ) -> Result<
587        Vec<super::super::super::super::objects::scout::video::api::SegmentSummary>,
588        conjure_http::private::Error,
589    >;
590    /// Generate an HLS playlist for a video file with the given RID to enable playback.
591    /// The HLS playlist will contain links to all of the video segments in the video in sequential order.
592    #[endpoint(
593        method = GET,
594        path = "/video-files/v1/video-files/{videoFileRid}/playlist",
595        name = "getPlaylist",
596        produces = conjure_http::server::conjure::BinaryResponseSerializer
597    )]
598    async fn get_playlist(
599        &self,
600        #[auth]
601        auth_: conjure_object::BearerToken,
602        #[path(
603            name = "videoFileRid",
604            decoder = conjure_http::server::conjure::FromPlainDecoder,
605            log_as = "videoFileRid"
606        )]
607        video_file_rid: conjure_object::ResourceIdentifier,
608    ) -> Result<Self::GetPlaylistBody, conjure_http::private::Error>;
609}
610/// The video service manages individual video files and their metadata.
611#[conjure_http::conjure_endpoints(
612    name = "VideoFileService",
613    use_legacy_error_serialization,
614    local
615)]
616pub trait LocalAsyncVideoFileService<#[response_writer] O> {
617    ///The body type returned by the `get_playlist` method.
618    type GetPlaylistBody: conjure_http::server::LocalAsyncWriteBody<O> + 'static;
619    /// Create and persist a video file entity with the given metadata
620    #[endpoint(
621        method = POST,
622        path = "/video-files/v1/video-files",
623        name = "create",
624        produces = conjure_http::server::StdResponseSerializer
625    )]
626    async fn create(
627        &self,
628        #[auth]
629        auth_: conjure_object::BearerToken,
630        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
631        request: super::super::super::super::objects::scout::video::api::CreateVideoFileRequest,
632    ) -> Result<
633        super::super::super::super::objects::scout::video::api::VideoFile,
634        conjure_http::private::Error,
635    >;
636    /// Returns video file metadata associated with a video file RID.
637    #[endpoint(
638        method = GET,
639        path = "/video-files/v1/video-files/{videoFileRid}",
640        name = "get",
641        produces = conjure_http::server::StdResponseSerializer
642    )]
643    async fn get(
644        &self,
645        #[auth]
646        auth_: conjure_object::BearerToken,
647        #[path(
648            name = "videoFileRid",
649            decoder = conjure_http::server::conjure::FromPlainDecoder,
650            log_as = "videoFileRid"
651        )]
652        video_file_rid: conjure_object::ResourceIdentifier,
653    ) -> Result<
654        super::super::super::super::objects::scout::video::api::VideoFile,
655        conjure_http::private::Error,
656    >;
657    /// Returns all video files and their metadata associated with the given RIDs
658    #[endpoint(
659        method = POST,
660        path = "/video-files/v1/video-files/batchGet",
661        name = "batchGet",
662        produces = conjure_http::server::conjure::CollectionResponseSerializer
663    )]
664    async fn batch_get(
665        &self,
666        #[auth]
667        auth_: conjure_object::BearerToken,
668        #[body(
669            deserializer = conjure_http::server::StdRequestDeserializer,
670            log_as = "videoFileRids"
671        )]
672        video_file_rids: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
673    ) -> Result<
674        std::collections::BTreeSet<
675            super::super::super::super::objects::scout::video::api::VideoFile,
676        >,
677        conjure_http::private::Error,
678    >;
679    #[endpoint(
680        method = POST,
681        path = "/video-files/v1/video-files/list-files-in-video",
682        name = "listFilesInVideo",
683        produces = conjure_http::server::conjure::CollectionResponseSerializer
684    )]
685    async fn list_files_in_video(
686        &self,
687        #[auth]
688        auth_: conjure_object::BearerToken,
689        #[body(
690            deserializer = conjure_http::server::StdRequestDeserializer,
691            log_as = "videoRid"
692        )]
693        video_rid: conjure_object::ResourceIdentifier,
694    ) -> Result<
695        std::collections::BTreeSet<
696            super::super::super::super::objects::scout::video::api::VideoFile,
697        >,
698        conjure_http::private::Error,
699    >;
700    /// Returns a paginated list of all video files and their metadata associated with the given video RID.
701    #[endpoint(
702        method = POST,
703        path = "/video-files/v1/video-files/list-files-in-video-paginated",
704        name = "listFilesInVideoPaginated",
705        produces = conjure_http::server::StdResponseSerializer
706    )]
707    async fn list_files_in_video_paginated(
708        &self,
709        #[auth]
710        auth_: conjure_object::BearerToken,
711        #[body(
712            deserializer = conjure_http::server::StdRequestDeserializer,
713            log_as = "videoRid"
714        )]
715        video_rid: super::super::super::super::objects::scout::video::api::ListFilesInVideoRequest,
716    ) -> Result<
717        super::super::super::super::objects::scout::video::api::ListFilesInVideoResponse,
718        conjure_http::private::Error,
719    >;
720    /// Updates the metadata for a video file associated with the given RID.
721    #[endpoint(
722        method = PUT,
723        path = "/video-files/v1/video-files/{videoFileRid}",
724        name = "update",
725        produces = conjure_http::server::StdResponseSerializer
726    )]
727    async fn update(
728        &self,
729        #[auth]
730        auth_: conjure_object::BearerToken,
731        #[path(
732            name = "videoFileRid",
733            decoder = conjure_http::server::conjure::FromPlainDecoder,
734            log_as = "videoFileRid"
735        )]
736        video_file_rid: conjure_object::ResourceIdentifier,
737        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
738        request: super::super::super::super::objects::scout::video::api::UpdateVideoFileRequest,
739    ) -> Result<
740        super::super::super::super::objects::scout::video::api::VideoFile,
741        conjure_http::private::Error,
742    >;
743    /// Updates metadata for multiple video files in a single video.
744    #[endpoint(
745        method = POST,
746        path = "/video-files/v1/video-files/batch-update",
747        name = "batchUpdate",
748        produces = conjure_http::server::StdResponseSerializer
749    )]
750    async fn batch_update(
751        &self,
752        #[auth]
753        auth_: conjure_object::BearerToken,
754        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
755        request: super::super::super::super::objects::scout::video::api::BatchUpdateVideoFilesRequest,
756    ) -> Result<
757        super::super::super::super::objects::scout::video::api::BatchUpdateVideoFilesResponse,
758        conjure_http::private::Error,
759    >;
760    /// Permanently deletes a video file and all associated segments from the database.
761    /// This operation cannot be undone.
762    #[endpoint(
763        method = DELETE,
764        path = "/video-files/v1/video-files/{videoFileRid}",
765        name = "delete"
766    )]
767    async fn delete(
768        &self,
769        #[auth]
770        auth_: conjure_object::BearerToken,
771        #[path(
772            name = "videoFileRid",
773            decoder = conjure_http::server::conjure::FromPlainDecoder,
774            log_as = "videoFileRid"
775        )]
776        video_file_rid: conjure_object::ResourceIdentifier,
777    ) -> Result<(), conjure_http::private::Error>;
778    #[endpoint(
779        method = PUT,
780        path = "/video-files/v1/video-files/{videoFileRid}/archive",
781        name = "archive"
782    )]
783    async fn archive(
784        &self,
785        #[auth]
786        auth_: conjure_object::BearerToken,
787        #[path(
788            name = "videoFileRid",
789            decoder = conjure_http::server::conjure::FromPlainDecoder,
790            log_as = "videoFileRid"
791        )]
792        video_file_rid: conjure_object::ResourceIdentifier,
793    ) -> Result<(), conjure_http::private::Error>;
794    #[endpoint(
795        method = PUT,
796        path = "/video-files/v1/video-files/{videoFileRid}/unarchive",
797        name = "unarchive"
798    )]
799    async fn unarchive(
800        &self,
801        #[auth]
802        auth_: conjure_object::BearerToken,
803        #[path(
804            name = "videoFileRid",
805            decoder = conjure_http::server::conjure::FromPlainDecoder,
806            log_as = "videoFileRid"
807        )]
808        video_file_rid: conjure_object::ResourceIdentifier,
809    ) -> Result<(), conjure_http::private::Error>;
810    /// Get the latest ingest status for a given video file by RID.
811    #[endpoint(
812        method = GET,
813        path = "/video-files/v1/video-files/{videoFileRid}/ingest-status",
814        name = "getIngestStatus",
815        produces = conjure_http::server::StdResponseSerializer
816    )]
817    async fn get_ingest_status(
818        &self,
819        #[auth]
820        auth_: conjure_object::BearerToken,
821        #[path(
822            name = "videoFileRid",
823            decoder = conjure_http::server::conjure::FromPlainDecoder,
824            log_as = "videoFileRid"
825        )]
826        video_file_rid: conjure_object::ResourceIdentifier,
827    ) -> Result<
828        super::super::super::super::objects::scout::video::api::GetIngestStatusResponse,
829        conjure_http::private::Error,
830    >;
831    /// Get the latest ingest status for a set of given video files by RID.
832    #[endpoint(
833        method = POST,
834        path = "/video-files/v1/videos/batch-get-ingest-status",
835        name = "batchGetIngestStatus",
836        produces = conjure_http::server::conjure::CollectionResponseSerializer
837    )]
838    async fn batch_get_ingest_status(
839        &self,
840        #[auth]
841        auth_: conjure_object::BearerToken,
842        #[body(
843            deserializer = conjure_http::server::StdRequestDeserializer,
844            log_as = "videoFileRids"
845        )]
846        video_file_rids: std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
847    ) -> Result<
848        std::collections::BTreeMap<
849            conjure_object::ResourceIdentifier,
850            super::super::super::super::objects::scout::video::api::VideoFileIngestStatus,
851        >,
852        conjure_http::private::Error,
853    >;
854    /// Update the latest ingest status for a given video file by RID.
855    #[endpoint(
856        method = PUT,
857        path = "/video-files/v1/videos/{videoFileRid}/ingest-status",
858        name = "updateIngestStatus"
859    )]
860    async fn update_ingest_status(
861        &self,
862        #[auth]
863        auth_: conjure_object::BearerToken,
864        #[path(
865            name = "videoFileRid",
866            decoder = conjure_http::server::conjure::FromPlainDecoder,
867            log_as = "videoFileRid"
868        )]
869        video_file_rid: conjure_object::ResourceIdentifier,
870        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
871        request: super::super::super::super::objects::scout::video::api::UpdateIngestStatusRequest,
872    ) -> Result<(), conjure_http::private::Error>;
873    /// Returns the min and max absolute and media timestamps for each segment in a video file.
874    /// To be used during frame-timestamp mapping when playing back videos.
875    #[endpoint(
876        method = GET,
877        path = "/video-files/v1/video-files/{videoFileRid}/segment-summaries",
878        name = "getSegmentSummaries",
879        produces = conjure_http::server::conjure::CollectionResponseSerializer
880    )]
881    async fn get_segment_summaries(
882        &self,
883        #[auth]
884        auth_: conjure_object::BearerToken,
885        #[path(
886            name = "videoFileRid",
887            decoder = conjure_http::server::conjure::FromPlainDecoder,
888            log_as = "videoFileRid"
889        )]
890        video_file_rid: conjure_object::ResourceIdentifier,
891    ) -> Result<
892        Vec<super::super::super::super::objects::scout::video::api::SegmentSummary>,
893        conjure_http::private::Error,
894    >;
895    /// Generate an HLS playlist for a video file with the given RID to enable playback.
896    /// The HLS playlist will contain links to all of the video segments in the video in sequential order.
897    #[endpoint(
898        method = GET,
899        path = "/video-files/v1/video-files/{videoFileRid}/playlist",
900        name = "getPlaylist",
901        produces = conjure_http::server::conjure::BinaryResponseSerializer
902    )]
903    async fn get_playlist(
904        &self,
905        #[auth]
906        auth_: conjure_object::BearerToken,
907        #[path(
908            name = "videoFileRid",
909            decoder = conjure_http::server::conjure::FromPlainDecoder,
910            log_as = "videoFileRid"
911        )]
912        video_file_rid: conjure_object::ResourceIdentifier,
913    ) -> Result<Self::GetPlaylistBody, conjure_http::private::Error>;
914}
nominal_api_conjure/conjure/endpoints/scout/video/video_file_service.rs

nominal_api_conjure/conjure/endpoints/scout/video/
video_file_service.rs
