Skip to main content

nominal_api/conjure/endpoints/scout/datareview/api/
data_review_service.rs

1use conjure_http::endpoint;
2/// The data review service manages the evaluation, disposition, and historical record of checks alerts.
3#[conjure_http::conjure_endpoints(
4    name = "DataReviewService",
5    use_legacy_error_serialization
6)]
7pub trait DataReviewService {
8    /// For each request, initiates data review for the requested run and checklist and executes
9    /// the automatic checks against the run.
10    #[endpoint(
11        method = POST,
12        path = "/scout/v2/data-review/batch-initiate",
13        name = "batchInitiate",
14        produces = conjure_http::server::StdResponseSerializer
15    )]
16    fn batch_initiate(
17        &self,
18        #[auth]
19        auth_: conjure_object::BearerToken,
20        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
21        request: super::super::super::super::super::objects::scout::datareview::api::BatchInitiateDataReviewRequest,
22    ) -> Result<
23        super::super::super::super::super::objects::scout::datareview::api::BatchInitiateDataReviewResponse,
24        conjure_http::private::Error,
25    >;
26    /// Re-executes the most recent failed automatic checks for the data review.
27    #[endpoint(
28        method = POST,
29        path = "/scout/v2/data-review/rerun-failed-automatic-checks",
30        name = "rerunFailedAutomaticChecks"
31    )]
32    fn rerun_failed_automatic_checks(
33        &self,
34        #[auth]
35        auth_: conjure_object::BearerToken,
36        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
37        request: super::super::super::super::super::objects::scout::datareview::api::RerunFailedAutomaticChecksRequest,
38    ) -> Result<(), conjure_http::private::Error>;
39    /// Returns the data reviews under the provided search parameters.
40    #[endpoint(
41        method = POST,
42        path = "/scout/v2/data-review/search",
43        name = "findDataReviews",
44        produces = conjure_http::server::StdResponseSerializer
45    )]
46    fn find_data_reviews(
47        &self,
48        #[auth]
49        auth_: conjure_object::BearerToken,
50        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
51        request: super::super::super::super::super::objects::scout::datareview::api::FindDataReviewsRequest,
52    ) -> Result<
53        super::super::super::super::super::objects::scout::datareview::api::DataReviewPage,
54        conjure_http::private::Error,
55    >;
56    /// Throws if not found.
57    #[endpoint(
58        method = GET,
59        path = "/scout/v2/data-review/{dataReviewRid}",
60        name = "get",
61        produces = conjure_http::server::StdResponseSerializer
62    )]
63    fn get(
64        &self,
65        #[auth]
66        auth_: conjure_object::BearerToken,
67        #[path(
68            name = "dataReviewRid",
69            decoder = conjure_http::server::conjure::FromPlainDecoder,
70            log_as = "dataReviewRid",
71            safe
72        )]
73        data_review_rid: super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
74    ) -> Result<
75        super::super::super::super::super::objects::scout::datareview::api::DataReview,
76        conjure_http::private::Error,
77    >;
78    /// Throws if not found.
79    #[endpoint(
80        method = GET,
81        path = "/scout/v2/data-review/check-alerts/{checkAlertRid}",
82        name = "getCheckAlert",
83        produces = conjure_http::server::StdResponseSerializer
84    )]
85    fn get_check_alert(
86        &self,
87        #[auth]
88        auth_: conjure_object::BearerToken,
89        #[path(
90            name = "checkAlertRid",
91            decoder = conjure_http::server::conjure::FromPlainDecoder,
92            log_as = "checkAlertRid",
93            safe
94        )]
95        check_alert_rid: super::super::super::super::super::objects::scout::rids::api::CheckAlertRid,
96    ) -> Result<
97        super::super::super::super::super::objects::scout::datareview::api::CheckAlert,
98        conjure_http::private::Error,
99    >;
100    /// Gets all check alerts from the provided data review.
101    #[endpoint(
102        method = GET,
103        path = "/scout/v2/data-review/{dataReviewRid}/check-alerts",
104        name = "getCheckAlertsForDataReview",
105        produces = conjure_http::server::conjure::CollectionResponseSerializer
106    )]
107    fn get_check_alerts_for_data_review(
108        &self,
109        #[auth]
110        auth_: conjure_object::BearerToken,
111        #[path(
112            name = "dataReviewRid",
113            decoder = conjure_http::server::conjure::FromPlainDecoder,
114            log_as = "dataReviewRid",
115            safe
116        )]
117        data_review_rid: super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
118    ) -> Result<
119        std::collections::BTreeSet<
120            super::super::super::super::super::objects::scout::datareview::api::CheckAlert,
121        >,
122        conjure_http::private::Error,
123    >;
124    /// Returns a histogram of alerts that occur across the provided runs or assets. At least one run or asset must be specified.
125    #[endpoint(
126        method = POST,
127        path = "/scout/v2/data-review/check-alerts/histogram",
128        name = "getCheckAlertsHistogram",
129        produces = conjure_http::server::StdResponseSerializer
130    )]
131    fn get_check_alerts_histogram(
132        &self,
133        #[auth]
134        auth_: conjure_object::BearerToken,
135        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
136        request: super::super::super::super::super::objects::scout::datareview::api::CheckAlertsHistogramRequest,
137    ) -> Result<
138        super::super::super::super::super::objects::scout::datareview::api::CheckAlertsHistogramResponse,
139        conjure_http::private::Error,
140    >;
141    /// Returns the check alerts under the provided search parameters. At least one run or asset must be specified.
142    #[endpoint(
143        method = POST,
144        path = "/scout/v2/data-review/check-alerts",
145        name = "searchCheckAlerts",
146        produces = conjure_http::server::StdResponseSerializer
147    )]
148    fn search_check_alerts(
149        &self,
150        #[auth]
151        auth_: conjure_object::BearerToken,
152        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
153        request: super::super::super::super::super::objects::scout::datareview::api::SearchCheckAlertsRequest,
154    ) -> Result<
155        super::super::super::super::super::objects::scout::datareview::api::SearchCheckAlertsResponse,
156        conjure_http::private::Error,
157    >;
158    /// Returns a record of the historical actions taken on the provided check alert.
159    #[endpoint(
160        method = GET,
161        path = "/scout/v2/data-review/check-alerts/{checkAlertRid}/action-log",
162        name = "getCheckAlertActionLog",
163        produces = conjure_http::server::StdResponseSerializer
164    )]
165    fn get_check_alert_action_log(
166        &self,
167        #[auth]
168        auth_: conjure_object::BearerToken,
169        #[path(
170            name = "checkAlertRid",
171            decoder = conjure_http::server::conjure::FromPlainDecoder,
172            log_as = "checkAlertRid",
173            safe
174        )]
175        check_alert_rid: super::super::super::super::super::objects::scout::rids::api::CheckAlertRid,
176    ) -> Result<
177        super::super::super::super::super::objects::scout::datareview::api::CheckAlertActionLog,
178        conjure_http::private::Error,
179    >;
180    /// Returns the number of alerts attached to each provided notebook.
181    #[endpoint(
182        method = POST,
183        path = "/scout/v2/data-review/get-check-alert-counts-for-notebooks",
184        name = "getCheckAlertCountsForNotebooks",
185        produces = conjure_http::server::conjure::CollectionResponseSerializer
186    )]
187    fn get_check_alert_counts_for_notebooks(
188        &self,
189        #[auth]
190        auth_: conjure_object::BearerToken,
191        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
192        rids: std::collections::BTreeSet<
193            super::super::super::super::super::objects::scout::rids::api::NotebookRid,
194        >,
195    ) -> Result<
196        std::collections::BTreeMap<
197            super::super::super::super::super::objects::scout::rids::api::NotebookRid,
198            i32,
199        >,
200        conjure_http::private::Error,
201    >;
202    /// Returns the check alert status of any linked violations for the provided notebooks. If none exist, an empty
203    /// optional is returned.
204    #[endpoint(
205        method = POST,
206        path = "/scout/v2/data-review/get-check-alert-status-for-notebooks",
207        name = "getCheckAlertStatusForNotebooks",
208        produces = conjure_http::server::conjure::CollectionResponseSerializer
209    )]
210    fn get_check_alert_status_for_notebooks(
211        &self,
212        #[auth]
213        auth_: conjure_object::BearerToken,
214        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
215        rids: std::collections::BTreeSet<
216            super::super::super::super::super::objects::scout::rids::api::NotebookRid,
217        >,
218    ) -> Result<
219        std::collections::BTreeMap<
220            super::super::super::super::super::objects::scout::rids::api::NotebookRid,
221            Option<
222                super::super::super::super::super::objects::scout::datareview::api::CheckAlertStatus,
223            >,
224        >,
225        conjure_http::private::Error,
226    >;
227    /// Applies a check alert action to the specified check alert RID.
228    #[endpoint(
229        method = PUT,
230        path = "/scout/v2/data-review/check-alerts/{checkAlertRid}",
231        name = "performCheckAlertAction",
232        produces = conjure_http::server::StdResponseSerializer
233    )]
234    fn perform_check_alert_action(
235        &self,
236        #[auth]
237        auth_: conjure_object::BearerToken,
238        #[path(
239            name = "checkAlertRid",
240            decoder = conjure_http::server::conjure::FromPlainDecoder,
241            log_as = "checkAlertRid",
242            safe
243        )]
244        check_alert_rid: super::super::super::super::super::objects::scout::rids::api::CheckAlertRid,
245        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
246        request: super::super::super::super::super::objects::scout::datareview::api::CheckAlertAction,
247    ) -> Result<
248        super::super::super::super::super::objects::scout::datareview::api::CheckAlert,
249        conjure_http::private::Error,
250    >;
251    /// Applies a check alert action to the specified check alert RIDs. If any of the check actions fail,
252    /// then none of the check actions will be applied.
253    #[endpoint(
254        method = POST,
255        path = "/scout/v2/data-review/check-alerts/batch-perform-action",
256        name = "batchPerformCheckAlertAction",
257        produces = conjure_http::server::StdResponseSerializer
258    )]
259    fn batch_perform_check_alert_action(
260        &self,
261        #[auth]
262        auth_: conjure_object::BearerToken,
263        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
264        request: super::super::super::super::super::objects::scout::datareview::api::BatchCheckAlertActionRequest,
265    ) -> Result<
266        super::super::super::super::super::objects::scout::datareview::api::BatchCheckAlertActionResponse,
267        conjure_http::private::Error,
268    >;
269    /// Applies an action to the specified check evaluation RIDs. If any of the check actions fail,
270    /// then none of the actions will be applied.
271    #[endpoint(
272        method = POST,
273        path = "/scout/v2/data-review/automatic-check-evaluation/batch-perform-action",
274        name = "batchPerformAutomaticCheckEvaluationReviewAction",
275        produces = conjure_http::server::StdResponseSerializer
276    )]
277    fn batch_perform_automatic_check_evaluation_review_action(
278        &self,
279        #[auth]
280        auth_: conjure_object::BearerToken,
281        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
282        request: super::super::super::super::super::objects::scout::datareview::api::BatchAutomaticCheckEvaluationActionRequest,
283    ) -> Result<
284        super::super::super::super::super::objects::scout::datareview::api::BatchAutomaticCheckEvaluationActionResponse,
285        conjure_http::private::Error,
286    >;
287    #[endpoint(
288        method = GET,
289        path = "/scout/v2/data-review/automatic-check-evaluation/{rid}/action-log",
290        name = "getAutomaticCheckEvaluationActionLog",
291        produces = conjure_http::server::StdResponseSerializer
292    )]
293    fn get_automatic_check_evaluation_action_log(
294        &self,
295        #[auth]
296        auth_: conjure_object::BearerToken,
297        #[path(
298            name = "rid",
299            decoder = conjure_http::server::conjure::FromPlainDecoder,
300            safe
301        )]
302        rid: super::super::super::super::super::objects::api::rids::AutomaticCheckEvaluationRid,
303    ) -> Result<
304        super::super::super::super::super::objects::scout::datareview::api::AutomaticCheckEvaluationActionLog,
305        conjure_http::private::Error,
306    >;
307    /// Applies an action to the specified check evaluation RIDs. If any of the check actions fail,
308    /// then none of the actions will be applied.
309    #[endpoint(
310        method = POST,
311        path = "/scout/v2/data-review/manual-check-evaluation/batch-perform-action",
312        name = "batchPerformManualCheckAlertAction"
313    )]
314    fn batch_perform_manual_check_alert_action(
315        &self,
316        #[auth]
317        auth_: conjure_object::BearerToken,
318        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
319        request: super::super::super::super::super::objects::scout::datareview::api::BatchManualCheckEvaluationActionRequest,
320    ) -> Result<(), conjure_http::private::Error>;
321    /// Returns a record of the historical manual actions taken on the provided check evaluation.
322    #[endpoint(
323        method = GET,
324        path = "/scout/v2/data-review/manual-check-evaluation/{rid}/action-log",
325        name = "getManualCheckEvaluationActionLog",
326        produces = conjure_http::server::StdResponseSerializer
327    )]
328    fn get_manual_check_evaluation_action_log(
329        &self,
330        #[auth]
331        auth_: conjure_object::BearerToken,
332        #[path(
333            name = "rid",
334            decoder = conjure_http::server::conjure::FromPlainDecoder,
335            safe
336        )]
337        rid: super::super::super::super::super::objects::scout::datareview::api::ManualCheckEvaluationRid,
338    ) -> Result<
339        super::super::super::super::super::objects::scout::datareview::api::ManualCheckEvaluationActionLog,
340        conjure_http::private::Error,
341    >;
342    /// Archives the data review with the given rid.
343    #[endpoint(
344        method = POST,
345        path = "/scout/v2/data-review/{dataReviewRid}/archive",
346        name = "archiveDataReview",
347        produces = conjure_http::server::StdResponseSerializer
348    )]
349    fn archive_data_review(
350        &self,
351        #[auth]
352        auth_: conjure_object::BearerToken,
353        #[path(
354            name = "dataReviewRid",
355            decoder = conjure_http::server::conjure::FromPlainDecoder,
356            log_as = "dataReviewRid",
357            safe
358        )]
359        data_review_rid: super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
360    ) -> Result<bool, conjure_http::private::Error>;
361    /// Batch archives the data reviews with the given rids.
362    #[endpoint(
363        method = POST,
364        path = "/scout/v2/data-review/batch-archive",
365        name = "batchArchiveDataReview"
366    )]
367    fn batch_archive_data_review(
368        &self,
369        #[auth]
370        auth_: conjure_object::BearerToken,
371        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
372        rids: std::collections::BTreeSet<
373            super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
374        >,
375    ) -> Result<(), conjure_http::private::Error>;
376    /// Unarchives the data review with the given rid.
377    #[endpoint(
378        method = POST,
379        path = "/scout/v2/data-review/unarchive/{dataReviewRid}",
380        name = "unarchiveDataReview"
381    )]
382    fn unarchive_data_review(
383        &self,
384        #[auth]
385        auth_: conjure_object::BearerToken,
386        #[path(
387            name = "dataReviewRid",
388            decoder = conjure_http::server::conjure::FromPlainDecoder,
389            log_as = "dataReviewRid",
390            safe
391        )]
392        data_review_rid: super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
393    ) -> Result<(), conjure_http::private::Error>;
394    #[endpoint(
395        method = POST,
396        path = "/scout/v2/data-review/data-review-check-metrics",
397        name = "getDataReviewCheckMetrics",
398        produces = conjure_http::server::StdResponseSerializer
399    )]
400    fn get_data_review_check_metrics(
401        &self,
402        #[auth]
403        auth_: conjure_object::BearerToken,
404        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
405        request: super::super::super::super::super::objects::scout::datareview::api::GetDataReviewCheckMetricsRequest,
406    ) -> Result<
407        super::super::super::super::super::objects::scout::datareview::api::GetDataReviewCheckMetricsResponse,
408        conjure_http::private::Error,
409    >;
410}
411/// The data review service manages the evaluation, disposition, and historical record of checks alerts.
412#[conjure_http::conjure_endpoints(
413    name = "DataReviewService",
414    use_legacy_error_serialization
415)]
416pub trait AsyncDataReviewService {
417    /// For each request, initiates data review for the requested run and checklist and executes
418    /// the automatic checks against the run.
419    #[endpoint(
420        method = POST,
421        path = "/scout/v2/data-review/batch-initiate",
422        name = "batchInitiate",
423        produces = conjure_http::server::StdResponseSerializer
424    )]
425    async fn batch_initiate(
426        &self,
427        #[auth]
428        auth_: conjure_object::BearerToken,
429        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
430        request: super::super::super::super::super::objects::scout::datareview::api::BatchInitiateDataReviewRequest,
431    ) -> Result<
432        super::super::super::super::super::objects::scout::datareview::api::BatchInitiateDataReviewResponse,
433        conjure_http::private::Error,
434    >;
435    /// Re-executes the most recent failed automatic checks for the data review.
436    #[endpoint(
437        method = POST,
438        path = "/scout/v2/data-review/rerun-failed-automatic-checks",
439        name = "rerunFailedAutomaticChecks"
440    )]
441    async fn rerun_failed_automatic_checks(
442        &self,
443        #[auth]
444        auth_: conjure_object::BearerToken,
445        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
446        request: super::super::super::super::super::objects::scout::datareview::api::RerunFailedAutomaticChecksRequest,
447    ) -> Result<(), conjure_http::private::Error>;
448    /// Returns the data reviews under the provided search parameters.
449    #[endpoint(
450        method = POST,
451        path = "/scout/v2/data-review/search",
452        name = "findDataReviews",
453        produces = conjure_http::server::StdResponseSerializer
454    )]
455    async fn find_data_reviews(
456        &self,
457        #[auth]
458        auth_: conjure_object::BearerToken,
459        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
460        request: super::super::super::super::super::objects::scout::datareview::api::FindDataReviewsRequest,
461    ) -> Result<
462        super::super::super::super::super::objects::scout::datareview::api::DataReviewPage,
463        conjure_http::private::Error,
464    >;
465    /// Throws if not found.
466    #[endpoint(
467        method = GET,
468        path = "/scout/v2/data-review/{dataReviewRid}",
469        name = "get",
470        produces = conjure_http::server::StdResponseSerializer
471    )]
472    async fn get(
473        &self,
474        #[auth]
475        auth_: conjure_object::BearerToken,
476        #[path(
477            name = "dataReviewRid",
478            decoder = conjure_http::server::conjure::FromPlainDecoder,
479            log_as = "dataReviewRid",
480            safe
481        )]
482        data_review_rid: super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
483    ) -> Result<
484        super::super::super::super::super::objects::scout::datareview::api::DataReview,
485        conjure_http::private::Error,
486    >;
487    /// Throws if not found.
488    #[endpoint(
489        method = GET,
490        path = "/scout/v2/data-review/check-alerts/{checkAlertRid}",
491        name = "getCheckAlert",
492        produces = conjure_http::server::StdResponseSerializer
493    )]
494    async fn get_check_alert(
495        &self,
496        #[auth]
497        auth_: conjure_object::BearerToken,
498        #[path(
499            name = "checkAlertRid",
500            decoder = conjure_http::server::conjure::FromPlainDecoder,
501            log_as = "checkAlertRid",
502            safe
503        )]
504        check_alert_rid: super::super::super::super::super::objects::scout::rids::api::CheckAlertRid,
505    ) -> Result<
506        super::super::super::super::super::objects::scout::datareview::api::CheckAlert,
507        conjure_http::private::Error,
508    >;
509    /// Gets all check alerts from the provided data review.
510    #[endpoint(
511        method = GET,
512        path = "/scout/v2/data-review/{dataReviewRid}/check-alerts",
513        name = "getCheckAlertsForDataReview",
514        produces = conjure_http::server::conjure::CollectionResponseSerializer
515    )]
516    async fn get_check_alerts_for_data_review(
517        &self,
518        #[auth]
519        auth_: conjure_object::BearerToken,
520        #[path(
521            name = "dataReviewRid",
522            decoder = conjure_http::server::conjure::FromPlainDecoder,
523            log_as = "dataReviewRid",
524            safe
525        )]
526        data_review_rid: super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
527    ) -> Result<
528        std::collections::BTreeSet<
529            super::super::super::super::super::objects::scout::datareview::api::CheckAlert,
530        >,
531        conjure_http::private::Error,
532    >;
533    /// Returns a histogram of alerts that occur across the provided runs or assets. At least one run or asset must be specified.
534    #[endpoint(
535        method = POST,
536        path = "/scout/v2/data-review/check-alerts/histogram",
537        name = "getCheckAlertsHistogram",
538        produces = conjure_http::server::StdResponseSerializer
539    )]
540    async fn get_check_alerts_histogram(
541        &self,
542        #[auth]
543        auth_: conjure_object::BearerToken,
544        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
545        request: super::super::super::super::super::objects::scout::datareview::api::CheckAlertsHistogramRequest,
546    ) -> Result<
547        super::super::super::super::super::objects::scout::datareview::api::CheckAlertsHistogramResponse,
548        conjure_http::private::Error,
549    >;
550    /// Returns the check alerts under the provided search parameters. At least one run or asset must be specified.
551    #[endpoint(
552        method = POST,
553        path = "/scout/v2/data-review/check-alerts",
554        name = "searchCheckAlerts",
555        produces = conjure_http::server::StdResponseSerializer
556    )]
557    async fn search_check_alerts(
558        &self,
559        #[auth]
560        auth_: conjure_object::BearerToken,
561        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
562        request: super::super::super::super::super::objects::scout::datareview::api::SearchCheckAlertsRequest,
563    ) -> Result<
564        super::super::super::super::super::objects::scout::datareview::api::SearchCheckAlertsResponse,
565        conjure_http::private::Error,
566    >;
567    /// Returns a record of the historical actions taken on the provided check alert.
568    #[endpoint(
569        method = GET,
570        path = "/scout/v2/data-review/check-alerts/{checkAlertRid}/action-log",
571        name = "getCheckAlertActionLog",
572        produces = conjure_http::server::StdResponseSerializer
573    )]
574    async fn get_check_alert_action_log(
575        &self,
576        #[auth]
577        auth_: conjure_object::BearerToken,
578        #[path(
579            name = "checkAlertRid",
580            decoder = conjure_http::server::conjure::FromPlainDecoder,
581            log_as = "checkAlertRid",
582            safe
583        )]
584        check_alert_rid: super::super::super::super::super::objects::scout::rids::api::CheckAlertRid,
585    ) -> Result<
586        super::super::super::super::super::objects::scout::datareview::api::CheckAlertActionLog,
587        conjure_http::private::Error,
588    >;
589    /// Returns the number of alerts attached to each provided notebook.
590    #[endpoint(
591        method = POST,
592        path = "/scout/v2/data-review/get-check-alert-counts-for-notebooks",
593        name = "getCheckAlertCountsForNotebooks",
594        produces = conjure_http::server::conjure::CollectionResponseSerializer
595    )]
596    async fn get_check_alert_counts_for_notebooks(
597        &self,
598        #[auth]
599        auth_: conjure_object::BearerToken,
600        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
601        rids: std::collections::BTreeSet<
602            super::super::super::super::super::objects::scout::rids::api::NotebookRid,
603        >,
604    ) -> Result<
605        std::collections::BTreeMap<
606            super::super::super::super::super::objects::scout::rids::api::NotebookRid,
607            i32,
608        >,
609        conjure_http::private::Error,
610    >;
611    /// Returns the check alert status of any linked violations for the provided notebooks. If none exist, an empty
612    /// optional is returned.
613    #[endpoint(
614        method = POST,
615        path = "/scout/v2/data-review/get-check-alert-status-for-notebooks",
616        name = "getCheckAlertStatusForNotebooks",
617        produces = conjure_http::server::conjure::CollectionResponseSerializer
618    )]
619    async fn get_check_alert_status_for_notebooks(
620        &self,
621        #[auth]
622        auth_: conjure_object::BearerToken,
623        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
624        rids: std::collections::BTreeSet<
625            super::super::super::super::super::objects::scout::rids::api::NotebookRid,
626        >,
627    ) -> Result<
628        std::collections::BTreeMap<
629            super::super::super::super::super::objects::scout::rids::api::NotebookRid,
630            Option<
631                super::super::super::super::super::objects::scout::datareview::api::CheckAlertStatus,
632            >,
633        >,
634        conjure_http::private::Error,
635    >;
636    /// Applies a check alert action to the specified check alert RID.
637    #[endpoint(
638        method = PUT,
639        path = "/scout/v2/data-review/check-alerts/{checkAlertRid}",
640        name = "performCheckAlertAction",
641        produces = conjure_http::server::StdResponseSerializer
642    )]
643    async fn perform_check_alert_action(
644        &self,
645        #[auth]
646        auth_: conjure_object::BearerToken,
647        #[path(
648            name = "checkAlertRid",
649            decoder = conjure_http::server::conjure::FromPlainDecoder,
650            log_as = "checkAlertRid",
651            safe
652        )]
653        check_alert_rid: super::super::super::super::super::objects::scout::rids::api::CheckAlertRid,
654        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
655        request: super::super::super::super::super::objects::scout::datareview::api::CheckAlertAction,
656    ) -> Result<
657        super::super::super::super::super::objects::scout::datareview::api::CheckAlert,
658        conjure_http::private::Error,
659    >;
660    /// Applies a check alert action to the specified check alert RIDs. If any of the check actions fail,
661    /// then none of the check actions will be applied.
662    #[endpoint(
663        method = POST,
664        path = "/scout/v2/data-review/check-alerts/batch-perform-action",
665        name = "batchPerformCheckAlertAction",
666        produces = conjure_http::server::StdResponseSerializer
667    )]
668    async fn batch_perform_check_alert_action(
669        &self,
670        #[auth]
671        auth_: conjure_object::BearerToken,
672        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
673        request: super::super::super::super::super::objects::scout::datareview::api::BatchCheckAlertActionRequest,
674    ) -> Result<
675        super::super::super::super::super::objects::scout::datareview::api::BatchCheckAlertActionResponse,
676        conjure_http::private::Error,
677    >;
678    /// Applies an action to the specified check evaluation RIDs. If any of the check actions fail,
679    /// then none of the actions will be applied.
680    #[endpoint(
681        method = POST,
682        path = "/scout/v2/data-review/automatic-check-evaluation/batch-perform-action",
683        name = "batchPerformAutomaticCheckEvaluationReviewAction",
684        produces = conjure_http::server::StdResponseSerializer
685    )]
686    async fn batch_perform_automatic_check_evaluation_review_action(
687        &self,
688        #[auth]
689        auth_: conjure_object::BearerToken,
690        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
691        request: super::super::super::super::super::objects::scout::datareview::api::BatchAutomaticCheckEvaluationActionRequest,
692    ) -> Result<
693        super::super::super::super::super::objects::scout::datareview::api::BatchAutomaticCheckEvaluationActionResponse,
694        conjure_http::private::Error,
695    >;
696    #[endpoint(
697        method = GET,
698        path = "/scout/v2/data-review/automatic-check-evaluation/{rid}/action-log",
699        name = "getAutomaticCheckEvaluationActionLog",
700        produces = conjure_http::server::StdResponseSerializer
701    )]
702    async fn get_automatic_check_evaluation_action_log(
703        &self,
704        #[auth]
705        auth_: conjure_object::BearerToken,
706        #[path(
707            name = "rid",
708            decoder = conjure_http::server::conjure::FromPlainDecoder,
709            safe
710        )]
711        rid: super::super::super::super::super::objects::api::rids::AutomaticCheckEvaluationRid,
712    ) -> Result<
713        super::super::super::super::super::objects::scout::datareview::api::AutomaticCheckEvaluationActionLog,
714        conjure_http::private::Error,
715    >;
716    /// Applies an action to the specified check evaluation RIDs. If any of the check actions fail,
717    /// then none of the actions will be applied.
718    #[endpoint(
719        method = POST,
720        path = "/scout/v2/data-review/manual-check-evaluation/batch-perform-action",
721        name = "batchPerformManualCheckAlertAction"
722    )]
723    async fn batch_perform_manual_check_alert_action(
724        &self,
725        #[auth]
726        auth_: conjure_object::BearerToken,
727        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
728        request: super::super::super::super::super::objects::scout::datareview::api::BatchManualCheckEvaluationActionRequest,
729    ) -> Result<(), conjure_http::private::Error>;
730    /// Returns a record of the historical manual actions taken on the provided check evaluation.
731    #[endpoint(
732        method = GET,
733        path = "/scout/v2/data-review/manual-check-evaluation/{rid}/action-log",
734        name = "getManualCheckEvaluationActionLog",
735        produces = conjure_http::server::StdResponseSerializer
736    )]
737    async fn get_manual_check_evaluation_action_log(
738        &self,
739        #[auth]
740        auth_: conjure_object::BearerToken,
741        #[path(
742            name = "rid",
743            decoder = conjure_http::server::conjure::FromPlainDecoder,
744            safe
745        )]
746        rid: super::super::super::super::super::objects::scout::datareview::api::ManualCheckEvaluationRid,
747    ) -> Result<
748        super::super::super::super::super::objects::scout::datareview::api::ManualCheckEvaluationActionLog,
749        conjure_http::private::Error,
750    >;
751    /// Archives the data review with the given rid.
752    #[endpoint(
753        method = POST,
754        path = "/scout/v2/data-review/{dataReviewRid}/archive",
755        name = "archiveDataReview",
756        produces = conjure_http::server::StdResponseSerializer
757    )]
758    async fn archive_data_review(
759        &self,
760        #[auth]
761        auth_: conjure_object::BearerToken,
762        #[path(
763            name = "dataReviewRid",
764            decoder = conjure_http::server::conjure::FromPlainDecoder,
765            log_as = "dataReviewRid",
766            safe
767        )]
768        data_review_rid: super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
769    ) -> Result<bool, conjure_http::private::Error>;
770    /// Batch archives the data reviews with the given rids.
771    #[endpoint(
772        method = POST,
773        path = "/scout/v2/data-review/batch-archive",
774        name = "batchArchiveDataReview"
775    )]
776    async fn batch_archive_data_review(
777        &self,
778        #[auth]
779        auth_: conjure_object::BearerToken,
780        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
781        rids: std::collections::BTreeSet<
782            super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
783        >,
784    ) -> Result<(), conjure_http::private::Error>;
785    /// Unarchives the data review with the given rid.
786    #[endpoint(
787        method = POST,
788        path = "/scout/v2/data-review/unarchive/{dataReviewRid}",
789        name = "unarchiveDataReview"
790    )]
791    async fn unarchive_data_review(
792        &self,
793        #[auth]
794        auth_: conjure_object::BearerToken,
795        #[path(
796            name = "dataReviewRid",
797            decoder = conjure_http::server::conjure::FromPlainDecoder,
798            log_as = "dataReviewRid",
799            safe
800        )]
801        data_review_rid: super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
802    ) -> Result<(), conjure_http::private::Error>;
803    #[endpoint(
804        method = POST,
805        path = "/scout/v2/data-review/data-review-check-metrics",
806        name = "getDataReviewCheckMetrics",
807        produces = conjure_http::server::StdResponseSerializer
808    )]
809    async fn get_data_review_check_metrics(
810        &self,
811        #[auth]
812        auth_: conjure_object::BearerToken,
813        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
814        request: super::super::super::super::super::objects::scout::datareview::api::GetDataReviewCheckMetricsRequest,
815    ) -> Result<
816        super::super::super::super::super::objects::scout::datareview::api::GetDataReviewCheckMetricsResponse,
817        conjure_http::private::Error,
818    >;
819}
820/// The data review service manages the evaluation, disposition, and historical record of checks alerts.
821#[conjure_http::conjure_endpoints(
822    name = "DataReviewService",
823    use_legacy_error_serialization,
824    local
825)]
826pub trait LocalAsyncDataReviewService {
827    /// For each request, initiates data review for the requested run and checklist and executes
828    /// the automatic checks against the run.
829    #[endpoint(
830        method = POST,
831        path = "/scout/v2/data-review/batch-initiate",
832        name = "batchInitiate",
833        produces = conjure_http::server::StdResponseSerializer
834    )]
835    async fn batch_initiate(
836        &self,
837        #[auth]
838        auth_: conjure_object::BearerToken,
839        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
840        request: super::super::super::super::super::objects::scout::datareview::api::BatchInitiateDataReviewRequest,
841    ) -> Result<
842        super::super::super::super::super::objects::scout::datareview::api::BatchInitiateDataReviewResponse,
843        conjure_http::private::Error,
844    >;
845    /// Re-executes the most recent failed automatic checks for the data review.
846    #[endpoint(
847        method = POST,
848        path = "/scout/v2/data-review/rerun-failed-automatic-checks",
849        name = "rerunFailedAutomaticChecks"
850    )]
851    async fn rerun_failed_automatic_checks(
852        &self,
853        #[auth]
854        auth_: conjure_object::BearerToken,
855        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
856        request: super::super::super::super::super::objects::scout::datareview::api::RerunFailedAutomaticChecksRequest,
857    ) -> Result<(), conjure_http::private::Error>;
858    /// Returns the data reviews under the provided search parameters.
859    #[endpoint(
860        method = POST,
861        path = "/scout/v2/data-review/search",
862        name = "findDataReviews",
863        produces = conjure_http::server::StdResponseSerializer
864    )]
865    async fn find_data_reviews(
866        &self,
867        #[auth]
868        auth_: conjure_object::BearerToken,
869        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
870        request: super::super::super::super::super::objects::scout::datareview::api::FindDataReviewsRequest,
871    ) -> Result<
872        super::super::super::super::super::objects::scout::datareview::api::DataReviewPage,
873        conjure_http::private::Error,
874    >;
875    /// Throws if not found.
876    #[endpoint(
877        method = GET,
878        path = "/scout/v2/data-review/{dataReviewRid}",
879        name = "get",
880        produces = conjure_http::server::StdResponseSerializer
881    )]
882    async fn get(
883        &self,
884        #[auth]
885        auth_: conjure_object::BearerToken,
886        #[path(
887            name = "dataReviewRid",
888            decoder = conjure_http::server::conjure::FromPlainDecoder,
889            log_as = "dataReviewRid",
890            safe
891        )]
892        data_review_rid: super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
893    ) -> Result<
894        super::super::super::super::super::objects::scout::datareview::api::DataReview,
895        conjure_http::private::Error,
896    >;
897    /// Throws if not found.
898    #[endpoint(
899        method = GET,
900        path = "/scout/v2/data-review/check-alerts/{checkAlertRid}",
901        name = "getCheckAlert",
902        produces = conjure_http::server::StdResponseSerializer
903    )]
904    async fn get_check_alert(
905        &self,
906        #[auth]
907        auth_: conjure_object::BearerToken,
908        #[path(
909            name = "checkAlertRid",
910            decoder = conjure_http::server::conjure::FromPlainDecoder,
911            log_as = "checkAlertRid",
912            safe
913        )]
914        check_alert_rid: super::super::super::super::super::objects::scout::rids::api::CheckAlertRid,
915    ) -> Result<
916        super::super::super::super::super::objects::scout::datareview::api::CheckAlert,
917        conjure_http::private::Error,
918    >;
919    /// Gets all check alerts from the provided data review.
920    #[endpoint(
921        method = GET,
922        path = "/scout/v2/data-review/{dataReviewRid}/check-alerts",
923        name = "getCheckAlertsForDataReview",
924        produces = conjure_http::server::conjure::CollectionResponseSerializer
925    )]
926    async fn get_check_alerts_for_data_review(
927        &self,
928        #[auth]
929        auth_: conjure_object::BearerToken,
930        #[path(
931            name = "dataReviewRid",
932            decoder = conjure_http::server::conjure::FromPlainDecoder,
933            log_as = "dataReviewRid",
934            safe
935        )]
936        data_review_rid: super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
937    ) -> Result<
938        std::collections::BTreeSet<
939            super::super::super::super::super::objects::scout::datareview::api::CheckAlert,
940        >,
941        conjure_http::private::Error,
942    >;
943    /// Returns a histogram of alerts that occur across the provided runs or assets. At least one run or asset must be specified.
944    #[endpoint(
945        method = POST,
946        path = "/scout/v2/data-review/check-alerts/histogram",
947        name = "getCheckAlertsHistogram",
948        produces = conjure_http::server::StdResponseSerializer
949    )]
950    async fn get_check_alerts_histogram(
951        &self,
952        #[auth]
953        auth_: conjure_object::BearerToken,
954        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
955        request: super::super::super::super::super::objects::scout::datareview::api::CheckAlertsHistogramRequest,
956    ) -> Result<
957        super::super::super::super::super::objects::scout::datareview::api::CheckAlertsHistogramResponse,
958        conjure_http::private::Error,
959    >;
960    /// Returns the check alerts under the provided search parameters. At least one run or asset must be specified.
961    #[endpoint(
962        method = POST,
963        path = "/scout/v2/data-review/check-alerts",
964        name = "searchCheckAlerts",
965        produces = conjure_http::server::StdResponseSerializer
966    )]
967    async fn search_check_alerts(
968        &self,
969        #[auth]
970        auth_: conjure_object::BearerToken,
971        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
972        request: super::super::super::super::super::objects::scout::datareview::api::SearchCheckAlertsRequest,
973    ) -> Result<
974        super::super::super::super::super::objects::scout::datareview::api::SearchCheckAlertsResponse,
975        conjure_http::private::Error,
976    >;
977    /// Returns a record of the historical actions taken on the provided check alert.
978    #[endpoint(
979        method = GET,
980        path = "/scout/v2/data-review/check-alerts/{checkAlertRid}/action-log",
981        name = "getCheckAlertActionLog",
982        produces = conjure_http::server::StdResponseSerializer
983    )]
984    async fn get_check_alert_action_log(
985        &self,
986        #[auth]
987        auth_: conjure_object::BearerToken,
988        #[path(
989            name = "checkAlertRid",
990            decoder = conjure_http::server::conjure::FromPlainDecoder,
991            log_as = "checkAlertRid",
992            safe
993        )]
994        check_alert_rid: super::super::super::super::super::objects::scout::rids::api::CheckAlertRid,
995    ) -> Result<
996        super::super::super::super::super::objects::scout::datareview::api::CheckAlertActionLog,
997        conjure_http::private::Error,
998    >;
999    /// Returns the number of alerts attached to each provided notebook.
1000    #[endpoint(
1001        method = POST,
1002        path = "/scout/v2/data-review/get-check-alert-counts-for-notebooks",
1003        name = "getCheckAlertCountsForNotebooks",
1004        produces = conjure_http::server::conjure::CollectionResponseSerializer
1005    )]
1006    async fn get_check_alert_counts_for_notebooks(
1007        &self,
1008        #[auth]
1009        auth_: conjure_object::BearerToken,
1010        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
1011        rids: std::collections::BTreeSet<
1012            super::super::super::super::super::objects::scout::rids::api::NotebookRid,
1013        >,
1014    ) -> Result<
1015        std::collections::BTreeMap<
1016            super::super::super::super::super::objects::scout::rids::api::NotebookRid,
1017            i32,
1018        >,
1019        conjure_http::private::Error,
1020    >;
1021    /// Returns the check alert status of any linked violations for the provided notebooks. If none exist, an empty
1022    /// optional is returned.
1023    #[endpoint(
1024        method = POST,
1025        path = "/scout/v2/data-review/get-check-alert-status-for-notebooks",
1026        name = "getCheckAlertStatusForNotebooks",
1027        produces = conjure_http::server::conjure::CollectionResponseSerializer
1028    )]
1029    async fn get_check_alert_status_for_notebooks(
1030        &self,
1031        #[auth]
1032        auth_: conjure_object::BearerToken,
1033        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
1034        rids: std::collections::BTreeSet<
1035            super::super::super::super::super::objects::scout::rids::api::NotebookRid,
1036        >,
1037    ) -> Result<
1038        std::collections::BTreeMap<
1039            super::super::super::super::super::objects::scout::rids::api::NotebookRid,
1040            Option<
1041                super::super::super::super::super::objects::scout::datareview::api::CheckAlertStatus,
1042            >,
1043        >,
1044        conjure_http::private::Error,
1045    >;
1046    /// Applies a check alert action to the specified check alert RID.
1047    #[endpoint(
1048        method = PUT,
1049        path = "/scout/v2/data-review/check-alerts/{checkAlertRid}",
1050        name = "performCheckAlertAction",
1051        produces = conjure_http::server::StdResponseSerializer
1052    )]
1053    async fn perform_check_alert_action(
1054        &self,
1055        #[auth]
1056        auth_: conjure_object::BearerToken,
1057        #[path(
1058            name = "checkAlertRid",
1059            decoder = conjure_http::server::conjure::FromPlainDecoder,
1060            log_as = "checkAlertRid",
1061            safe
1062        )]
1063        check_alert_rid: super::super::super::super::super::objects::scout::rids::api::CheckAlertRid,
1064        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1065        request: super::super::super::super::super::objects::scout::datareview::api::CheckAlertAction,
1066    ) -> Result<
1067        super::super::super::super::super::objects::scout::datareview::api::CheckAlert,
1068        conjure_http::private::Error,
1069    >;
1070    /// Applies a check alert action to the specified check alert RIDs. If any of the check actions fail,
1071    /// then none of the check actions will be applied.
1072    #[endpoint(
1073        method = POST,
1074        path = "/scout/v2/data-review/check-alerts/batch-perform-action",
1075        name = "batchPerformCheckAlertAction",
1076        produces = conjure_http::server::StdResponseSerializer
1077    )]
1078    async fn batch_perform_check_alert_action(
1079        &self,
1080        #[auth]
1081        auth_: conjure_object::BearerToken,
1082        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1083        request: super::super::super::super::super::objects::scout::datareview::api::BatchCheckAlertActionRequest,
1084    ) -> Result<
1085        super::super::super::super::super::objects::scout::datareview::api::BatchCheckAlertActionResponse,
1086        conjure_http::private::Error,
1087    >;
1088    /// Applies an action to the specified check evaluation RIDs. If any of the check actions fail,
1089    /// then none of the actions will be applied.
1090    #[endpoint(
1091        method = POST,
1092        path = "/scout/v2/data-review/automatic-check-evaluation/batch-perform-action",
1093        name = "batchPerformAutomaticCheckEvaluationReviewAction",
1094        produces = conjure_http::server::StdResponseSerializer
1095    )]
1096    async fn batch_perform_automatic_check_evaluation_review_action(
1097        &self,
1098        #[auth]
1099        auth_: conjure_object::BearerToken,
1100        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1101        request: super::super::super::super::super::objects::scout::datareview::api::BatchAutomaticCheckEvaluationActionRequest,
1102    ) -> Result<
1103        super::super::super::super::super::objects::scout::datareview::api::BatchAutomaticCheckEvaluationActionResponse,
1104        conjure_http::private::Error,
1105    >;
1106    #[endpoint(
1107        method = GET,
1108        path = "/scout/v2/data-review/automatic-check-evaluation/{rid}/action-log",
1109        name = "getAutomaticCheckEvaluationActionLog",
1110        produces = conjure_http::server::StdResponseSerializer
1111    )]
1112    async fn get_automatic_check_evaluation_action_log(
1113        &self,
1114        #[auth]
1115        auth_: conjure_object::BearerToken,
1116        #[path(
1117            name = "rid",
1118            decoder = conjure_http::server::conjure::FromPlainDecoder,
1119            safe
1120        )]
1121        rid: super::super::super::super::super::objects::api::rids::AutomaticCheckEvaluationRid,
1122    ) -> Result<
1123        super::super::super::super::super::objects::scout::datareview::api::AutomaticCheckEvaluationActionLog,
1124        conjure_http::private::Error,
1125    >;
1126    /// Applies an action to the specified check evaluation RIDs. If any of the check actions fail,
1127    /// then none of the actions will be applied.
1128    #[endpoint(
1129        method = POST,
1130        path = "/scout/v2/data-review/manual-check-evaluation/batch-perform-action",
1131        name = "batchPerformManualCheckAlertAction"
1132    )]
1133    async fn batch_perform_manual_check_alert_action(
1134        &self,
1135        #[auth]
1136        auth_: conjure_object::BearerToken,
1137        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1138        request: super::super::super::super::super::objects::scout::datareview::api::BatchManualCheckEvaluationActionRequest,
1139    ) -> Result<(), conjure_http::private::Error>;
1140    /// Returns a record of the historical manual actions taken on the provided check evaluation.
1141    #[endpoint(
1142        method = GET,
1143        path = "/scout/v2/data-review/manual-check-evaluation/{rid}/action-log",
1144        name = "getManualCheckEvaluationActionLog",
1145        produces = conjure_http::server::StdResponseSerializer
1146    )]
1147    async fn get_manual_check_evaluation_action_log(
1148        &self,
1149        #[auth]
1150        auth_: conjure_object::BearerToken,
1151        #[path(
1152            name = "rid",
1153            decoder = conjure_http::server::conjure::FromPlainDecoder,
1154            safe
1155        )]
1156        rid: super::super::super::super::super::objects::scout::datareview::api::ManualCheckEvaluationRid,
1157    ) -> Result<
1158        super::super::super::super::super::objects::scout::datareview::api::ManualCheckEvaluationActionLog,
1159        conjure_http::private::Error,
1160    >;
1161    /// Archives the data review with the given rid.
1162    #[endpoint(
1163        method = POST,
1164        path = "/scout/v2/data-review/{dataReviewRid}/archive",
1165        name = "archiveDataReview",
1166        produces = conjure_http::server::StdResponseSerializer
1167    )]
1168    async fn archive_data_review(
1169        &self,
1170        #[auth]
1171        auth_: conjure_object::BearerToken,
1172        #[path(
1173            name = "dataReviewRid",
1174            decoder = conjure_http::server::conjure::FromPlainDecoder,
1175            log_as = "dataReviewRid",
1176            safe
1177        )]
1178        data_review_rid: super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
1179    ) -> Result<bool, conjure_http::private::Error>;
1180    /// Batch archives the data reviews with the given rids.
1181    #[endpoint(
1182        method = POST,
1183        path = "/scout/v2/data-review/batch-archive",
1184        name = "batchArchiveDataReview"
1185    )]
1186    async fn batch_archive_data_review(
1187        &self,
1188        #[auth]
1189        auth_: conjure_object::BearerToken,
1190        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
1191        rids: std::collections::BTreeSet<
1192            super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
1193        >,
1194    ) -> Result<(), conjure_http::private::Error>;
1195    /// Unarchives the data review with the given rid.
1196    #[endpoint(
1197        method = POST,
1198        path = "/scout/v2/data-review/unarchive/{dataReviewRid}",
1199        name = "unarchiveDataReview"
1200    )]
1201    async fn unarchive_data_review(
1202        &self,
1203        #[auth]
1204        auth_: conjure_object::BearerToken,
1205        #[path(
1206            name = "dataReviewRid",
1207            decoder = conjure_http::server::conjure::FromPlainDecoder,
1208            log_as = "dataReviewRid",
1209            safe
1210        )]
1211        data_review_rid: super::super::super::super::super::objects::scout::rids::api::DataReviewRid,
1212    ) -> Result<(), conjure_http::private::Error>;
1213    #[endpoint(
1214        method = POST,
1215        path = "/scout/v2/data-review/data-review-check-metrics",
1216        name = "getDataReviewCheckMetrics",
1217        produces = conjure_http::server::StdResponseSerializer
1218    )]
1219    async fn get_data_review_check_metrics(
1220        &self,
1221        #[auth]
1222        auth_: conjure_object::BearerToken,
1223        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
1224        request: super::super::super::super::super::objects::scout::datareview::api::GetDataReviewCheckMetricsRequest,
1225    ) -> Result<
1226        super::super::super::super::super::objects::scout::datareview::api::GetDataReviewCheckMetricsResponse,
1227        conjure_http::private::Error,
1228    >;
1229}