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

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