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

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