Skip to main content

nominal_api/conjure/clients/scout/checks/api/
checklist_service.rs

1use conjure_http::endpoint;
2/// The Checklist Service is responsible for managing checklists and checks.
3/// A checklist is a collection of checks that can be executed against a set of data sources.
4#[conjure_http::conjure_client(name = "ChecklistService")]
5pub trait ChecklistService<
6    #[response_body]
7    I: Iterator<
8            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
9        >,
10> {
11    /// Creates a new checklist with the provided checks.
12    #[endpoint(
13        method = POST,
14        path = "/scout/v1/checklists",
15        name = "create",
16        accept = conjure_http::client::StdResponseDeserializer
17    )]
18    fn create(
19        &self,
20        #[auth]
21        auth_: &conjure_object::BearerToken,
22        #[body(serializer = conjure_http::client::StdRequestSerializer)]
23        request: &super::super::super::super::super::objects::scout::checks::api::CreateChecklistRequest,
24    ) -> Result<
25        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
26        conjure_http::private::Error,
27    >;
28    /// Creates a permanent commit with a commit message.
29    /// Throws if the checklist or branch doesn't exist.
30    /// Throws if the latest commit doesn't match the provided id.
31    /// Throws if you commit to an archived checklist.
32    #[endpoint(
33        method = POST,
34        path = "/scout/v1/checklists/{checklistRid}/commit",
35        name = "commit",
36        accept = conjure_http::client::StdResponseDeserializer
37    )]
38    fn commit(
39        &self,
40        #[auth]
41        auth_: &conjure_object::BearerToken,
42        #[path(
43            name = "checklistRid",
44            encoder = conjure_http::client::conjure::PlainEncoder
45        )]
46        checklist_rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
47        #[query(
48            name = "branch",
49            encoder = conjure_http::client::conjure::PlainSeqEncoder
50        )]
51        branch: Option<
52            &super::super::super::super::super::objects::scout::versioning::api::BranchName,
53        >,
54        #[body(serializer = conjure_http::client::StdRequestSerializer)]
55        request: &super::super::super::super::super::objects::scout::checks::api::CommitChecklistRequest,
56    ) -> Result<
57        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
58        conjure_http::private::Error,
59    >;
60    /// Creates a commit that may be compacted, e.g cleaned up and not exist anymore.
61    /// Throws if the checklist or branch doesn't exist.
62    /// Throws if the latest commit doesn't match the provided id.
63    /// Throws if you save to an archived checklist.
64    #[endpoint(
65        method = POST,
66        path = "/scout/v1/checklists/{checklistRid}/save-working-state",
67        name = "saveWorkingState",
68        accept = conjure_http::client::StdResponseDeserializer
69    )]
70    fn save_working_state(
71        &self,
72        #[auth]
73        auth_: &conjure_object::BearerToken,
74        #[path(
75            name = "checklistRid",
76            encoder = conjure_http::client::conjure::PlainEncoder
77        )]
78        checklist_rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
79        #[query(
80            name = "branch",
81            encoder = conjure_http::client::conjure::PlainSeqEncoder
82        )]
83        branch: Option<
84            &super::super::super::super::super::objects::scout::versioning::api::BranchName,
85        >,
86        #[body(serializer = conjure_http::client::StdRequestSerializer)]
87        request: &super::super::super::super::super::objects::scout::checks::api::SaveChecklistRequest,
88    ) -> Result<
89        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
90        conjure_http::private::Error,
91    >;
92    /// Merges the given branch to the "main" branch.
93    /// Throws if the checklist or branch doesn't exist.
94    /// Throws if the latest commit doesn't match the provided id.
95    /// Throws if you merge with an archived checklist.
96    #[endpoint(
97        method = POST,
98        path = "/scout/v1/checklists/{checklistRid}/merge-to-main",
99        name = "mergeToMain",
100        accept = conjure_http::client::StdResponseDeserializer
101    )]
102    fn merge_to_main(
103        &self,
104        #[auth]
105        auth_: &conjure_object::BearerToken,
106        #[path(
107            name = "checklistRid",
108            encoder = conjure_http::client::conjure::PlainEncoder
109        )]
110        checklist_rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
111        #[body(serializer = conjure_http::client::StdRequestSerializer)]
112        request: &super::super::super::super::super::objects::scout::checks::api::MergeToMainRequest,
113    ) -> Result<
114        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
115        conjure_http::private::Error,
116    >;
117    /// Updates the data source ref names for all checks within a checklist.
118    /// Throws if the checklist doesn't exist.
119    #[endpoint(
120        method = POST,
121        path = "/scout/v1/checklists/{checklistRid}/update-ref-names",
122        name = "updateDataSourceRefNames",
123        accept = conjure_http::client::StdResponseDeserializer
124    )]
125    fn update_data_source_ref_names(
126        &self,
127        #[auth]
128        auth_: &conjure_object::BearerToken,
129        #[path(
130            name = "checklistRid",
131            encoder = conjure_http::client::conjure::PlainEncoder
132        )]
133        checklist_rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
134        #[query(
135            name = "branch",
136            encoder = conjure_http::client::conjure::PlainSeqEncoder
137        )]
138        branch: Option<
139            &super::super::super::super::super::objects::scout::versioning::api::BranchName,
140        >,
141        #[body(serializer = conjure_http::client::StdRequestSerializer)]
142        ref_name_updates: &std::collections::BTreeMap<
143            super::super::super::super::super::objects::scout::api::DataSourceRefName,
144            super::super::super::super::super::objects::scout::api::DataSourceRefName,
145        >,
146    ) -> Result<
147        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
148        conjure_http::private::Error,
149    >;
150    /// Updates the metadata of a checklist.
151    #[endpoint(
152        method = PUT,
153        path = "/scout/v1/checklists/{rid}/update-metadata",
154        name = "updateMetadata",
155        accept = conjure_http::client::StdResponseDeserializer
156    )]
157    fn update_metadata(
158        &self,
159        #[auth]
160        auth_: &conjure_object::BearerToken,
161        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
162        rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
163        #[body(serializer = conjure_http::client::StdRequestSerializer)]
164        request: &super::super::super::super::super::objects::scout::checks::api::UpdateChecklistMetadataRequest,
165    ) -> Result<
166        super::super::super::super::super::objects::scout::checks::api::ChecklistMetadata,
167        conjure_http::private::Error,
168    >;
169    /// Specify at most one of (branch, commit).
170    /// If neither is specified, branch = "main" is the default.
171    #[endpoint(
172        method = GET,
173        path = "/scout/v1/checklists/{rid}",
174        name = "get",
175        accept = conjure_http::client::StdResponseDeserializer
176    )]
177    fn get(
178        &self,
179        #[auth]
180        auth_: &conjure_object::BearerToken,
181        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
182        rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
183        #[query(
184            name = "branch",
185            encoder = conjure_http::client::conjure::PlainSeqEncoder
186        )]
187        branch: Option<
188            &super::super::super::super::super::objects::scout::versioning::api::BranchName,
189        >,
190        #[query(
191            name = "commit",
192            encoder = conjure_http::client::conjure::PlainSeqEncoder
193        )]
194        commit: Option<
195            &super::super::super::super::super::objects::scout::versioning::api::CommitId,
196        >,
197    ) -> Result<
198        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
199        conjure_http::private::Error,
200    >;
201    /// Returns the pinned commit for each provided checklist reference.
202    #[endpoint(
203        method = POST,
204        path = "/scout/v1/checklists/batch-get",
205        name = "batchGet",
206        accept = conjure_http::client::conjure::CollectionResponseDeserializer
207    )]
208    fn batch_get(
209        &self,
210        #[auth]
211        auth_: &conjure_object::BearerToken,
212        #[body(serializer = conjure_http::client::StdRequestSerializer)]
213        checklist_refs: &std::collections::BTreeSet<
214            super::super::super::super::super::objects::scout::checks::api::PinnedChecklistRef,
215        >,
216    ) -> Result<
217        std::collections::BTreeSet<
218            super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
219        >,
220        conjure_http::private::Error,
221    >;
222    /// Returns the metadata for each provided checklist.
223    #[endpoint(
224        method = POST,
225        path = "/scout/v1/checklists/batch-get-metadata",
226        name = "batchGetMetadata",
227        accept = conjure_http::client::StdResponseDeserializer
228    )]
229    fn batch_get_metadata(
230        &self,
231        #[auth]
232        auth_: &conjure_object::BearerToken,
233        #[body(serializer = conjure_http::client::StdRequestSerializer)]
234        request: &super::super::super::super::super::objects::scout::checks::api::BatchGetChecklistMetadataRequest,
235    ) -> Result<
236        super::super::super::super::super::objects::scout::checks::api::BatchGetChecklistMetadataResponse,
237        conjure_http::private::Error,
238    >;
239    /// Results will be the latest commit on main for each checklist.
240    #[endpoint(
241        method = POST,
242        path = "/scout/v1/checklists/search",
243        name = "search",
244        accept = conjure_http::client::StdResponseDeserializer
245    )]
246    fn search(
247        &self,
248        #[auth]
249        auth_: &conjure_object::BearerToken,
250        #[body(serializer = conjure_http::client::StdRequestSerializer)]
251        request: &super::super::super::super::super::objects::scout::checks::api::SearchChecklistsRequest,
252    ) -> Result<
253        super::super::super::super::super::objects::scout::checks::api::VersionedChecklistPage,
254        conjure_http::private::Error,
255    >;
256    /// Archives the provided checklists.
257    #[endpoint(
258        method = POST,
259        path = "/scout/v1/checklists/archive",
260        name = "archive",
261        accept = conjure_http::client::conjure::EmptyResponseDeserializer
262    )]
263    fn archive(
264        &self,
265        #[auth]
266        auth_: &conjure_object::BearerToken,
267        #[body(serializer = conjure_http::client::StdRequestSerializer)]
268        request: &super::super::super::super::super::objects::scout::checks::api::ArchiveChecklistsRequest,
269    ) -> Result<(), conjure_http::private::Error>;
270    /// Unarchives the provided checklists.
271    #[endpoint(
272        method = POST,
273        path = "/scout/v1/checklists/unarchive",
274        name = "unarchive",
275        accept = conjure_http::client::conjure::EmptyResponseDeserializer
276    )]
277    fn unarchive(
278        &self,
279        #[auth]
280        auth_: &conjure_object::BearerToken,
281        #[body(serializer = conjure_http::client::StdRequestSerializer)]
282        request: &super::super::super::super::super::objects::scout::checks::api::UnarchiveChecklistsRequest,
283    ) -> Result<(), conjure_http::private::Error>;
284    /// Returns the check with the given rid.
285    #[endpoint(
286        method = GET,
287        path = "/scout/v1/checklists/check/{rid}",
288        name = "getCheck",
289        accept = conjure_http::client::StdResponseDeserializer
290    )]
291    fn get_check(
292        &self,
293        #[auth]
294        auth_: &conjure_object::BearerToken,
295        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
296        rid: &super::super::super::super::super::objects::scout::rids::api::CheckRid,
297    ) -> Result<
298        super::super::super::super::super::objects::scout::checks::api::Check,
299        conjure_http::private::Error,
300    >;
301    /// Returns the checks with the given rids.
302    #[endpoint(
303        method = POST,
304        path = "/scout/v1/checklists/check/batch-get",
305        name = "batchGetChecks",
306        accept = conjure_http::client::conjure::CollectionResponseDeserializer
307    )]
308    fn batch_get_checks(
309        &self,
310        #[auth]
311        auth_: &conjure_object::BearerToken,
312        #[body(serializer = conjure_http::client::StdRequestSerializer)]
313        rids: &std::collections::BTreeSet<
314            super::super::super::super::super::objects::scout::rids::api::CheckRid,
315        >,
316    ) -> Result<
317        std::collections::BTreeSet<
318            super::super::super::super::super::objects::scout::checks::api::Check,
319        >,
320        conjure_http::private::Error,
321    >;
322    /// Returns all labels and properties.
323    #[endpoint(
324        method = GET,
325        path = "/scout/v1/checklists/get-all-labels-properties",
326        name = "getAllLabelsAndProperties",
327        accept = conjure_http::client::StdResponseDeserializer
328    )]
329    fn get_all_labels_and_properties(
330        &self,
331        #[auth]
332        auth_: &conjure_object::BearerToken,
333        #[query(
334            name = "workspaces",
335            encoder = conjure_http::client::conjure::PlainSeqEncoder
336        )]
337        workspaces: &std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
338    ) -> Result<
339        super::super::super::super::super::objects::scout::checks::api::GetAllLabelsAndPropertiesResponse,
340        conjure_http::private::Error,
341    >;
342    /// Batch edits metadata across multiple checklists. Supports rename/merge for labels and properties.
343    /// If more than 1000 checklists are targeted, this endpoint will throw a 400.
344    #[endpoint(
345        method = POST,
346        path = "/scout/v1/checklists/metadata/batch-edit",
347        name = "batchEditChecklistMetadata",
348        accept = conjure_http::client::StdResponseDeserializer
349    )]
350    fn batch_edit_checklist_metadata(
351        &self,
352        #[auth]
353        auth_: &conjure_object::BearerToken,
354        #[body(serializer = conjure_http::client::StdRequestSerializer)]
355        request: &super::super::super::super::super::objects::scout::checks::api::BatchEditChecklistMetadataRequest,
356    ) -> Result<
357        super::super::super::super::super::objects::scout::checks::api::BatchEditChecklistMetadataResponse,
358        conjure_http::private::Error,
359    >;
360}
361/// The Checklist Service is responsible for managing checklists and checks.
362/// A checklist is a collection of checks that can be executed against a set of data sources.
363#[conjure_http::conjure_client(name = "ChecklistService")]
364pub trait AsyncChecklistService<
365    #[response_body]
366    I: conjure_http::private::Stream<
367            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
368        >,
369> {
370    /// Creates a new checklist with the provided checks.
371    #[endpoint(
372        method = POST,
373        path = "/scout/v1/checklists",
374        name = "create",
375        accept = conjure_http::client::StdResponseDeserializer
376    )]
377    async fn create(
378        &self,
379        #[auth]
380        auth_: &conjure_object::BearerToken,
381        #[body(serializer = conjure_http::client::StdRequestSerializer)]
382        request: &super::super::super::super::super::objects::scout::checks::api::CreateChecklistRequest,
383    ) -> Result<
384        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
385        conjure_http::private::Error,
386    >;
387    /// Creates a permanent commit with a commit message.
388    /// Throws if the checklist or branch doesn't exist.
389    /// Throws if the latest commit doesn't match the provided id.
390    /// Throws if you commit to an archived checklist.
391    #[endpoint(
392        method = POST,
393        path = "/scout/v1/checklists/{checklistRid}/commit",
394        name = "commit",
395        accept = conjure_http::client::StdResponseDeserializer
396    )]
397    async fn commit(
398        &self,
399        #[auth]
400        auth_: &conjure_object::BearerToken,
401        #[path(
402            name = "checklistRid",
403            encoder = conjure_http::client::conjure::PlainEncoder
404        )]
405        checklist_rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
406        #[query(
407            name = "branch",
408            encoder = conjure_http::client::conjure::PlainSeqEncoder
409        )]
410        branch: Option<
411            &super::super::super::super::super::objects::scout::versioning::api::BranchName,
412        >,
413        #[body(serializer = conjure_http::client::StdRequestSerializer)]
414        request: &super::super::super::super::super::objects::scout::checks::api::CommitChecklistRequest,
415    ) -> Result<
416        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
417        conjure_http::private::Error,
418    >;
419    /// Creates a commit that may be compacted, e.g cleaned up and not exist anymore.
420    /// Throws if the checklist or branch doesn't exist.
421    /// Throws if the latest commit doesn't match the provided id.
422    /// Throws if you save to an archived checklist.
423    #[endpoint(
424        method = POST,
425        path = "/scout/v1/checklists/{checklistRid}/save-working-state",
426        name = "saveWorkingState",
427        accept = conjure_http::client::StdResponseDeserializer
428    )]
429    async fn save_working_state(
430        &self,
431        #[auth]
432        auth_: &conjure_object::BearerToken,
433        #[path(
434            name = "checklistRid",
435            encoder = conjure_http::client::conjure::PlainEncoder
436        )]
437        checklist_rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
438        #[query(
439            name = "branch",
440            encoder = conjure_http::client::conjure::PlainSeqEncoder
441        )]
442        branch: Option<
443            &super::super::super::super::super::objects::scout::versioning::api::BranchName,
444        >,
445        #[body(serializer = conjure_http::client::StdRequestSerializer)]
446        request: &super::super::super::super::super::objects::scout::checks::api::SaveChecklistRequest,
447    ) -> Result<
448        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
449        conjure_http::private::Error,
450    >;
451    /// Merges the given branch to the "main" branch.
452    /// Throws if the checklist or branch doesn't exist.
453    /// Throws if the latest commit doesn't match the provided id.
454    /// Throws if you merge with an archived checklist.
455    #[endpoint(
456        method = POST,
457        path = "/scout/v1/checklists/{checklistRid}/merge-to-main",
458        name = "mergeToMain",
459        accept = conjure_http::client::StdResponseDeserializer
460    )]
461    async fn merge_to_main(
462        &self,
463        #[auth]
464        auth_: &conjure_object::BearerToken,
465        #[path(
466            name = "checklistRid",
467            encoder = conjure_http::client::conjure::PlainEncoder
468        )]
469        checklist_rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
470        #[body(serializer = conjure_http::client::StdRequestSerializer)]
471        request: &super::super::super::super::super::objects::scout::checks::api::MergeToMainRequest,
472    ) -> Result<
473        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
474        conjure_http::private::Error,
475    >;
476    /// Updates the data source ref names for all checks within a checklist.
477    /// Throws if the checklist doesn't exist.
478    #[endpoint(
479        method = POST,
480        path = "/scout/v1/checklists/{checklistRid}/update-ref-names",
481        name = "updateDataSourceRefNames",
482        accept = conjure_http::client::StdResponseDeserializer
483    )]
484    async fn update_data_source_ref_names(
485        &self,
486        #[auth]
487        auth_: &conjure_object::BearerToken,
488        #[path(
489            name = "checklistRid",
490            encoder = conjure_http::client::conjure::PlainEncoder
491        )]
492        checklist_rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
493        #[query(
494            name = "branch",
495            encoder = conjure_http::client::conjure::PlainSeqEncoder
496        )]
497        branch: Option<
498            &super::super::super::super::super::objects::scout::versioning::api::BranchName,
499        >,
500        #[body(serializer = conjure_http::client::StdRequestSerializer)]
501        ref_name_updates: &std::collections::BTreeMap<
502            super::super::super::super::super::objects::scout::api::DataSourceRefName,
503            super::super::super::super::super::objects::scout::api::DataSourceRefName,
504        >,
505    ) -> Result<
506        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
507        conjure_http::private::Error,
508    >;
509    /// Updates the metadata of a checklist.
510    #[endpoint(
511        method = PUT,
512        path = "/scout/v1/checklists/{rid}/update-metadata",
513        name = "updateMetadata",
514        accept = conjure_http::client::StdResponseDeserializer
515    )]
516    async fn update_metadata(
517        &self,
518        #[auth]
519        auth_: &conjure_object::BearerToken,
520        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
521        rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
522        #[body(serializer = conjure_http::client::StdRequestSerializer)]
523        request: &super::super::super::super::super::objects::scout::checks::api::UpdateChecklistMetadataRequest,
524    ) -> Result<
525        super::super::super::super::super::objects::scout::checks::api::ChecklistMetadata,
526        conjure_http::private::Error,
527    >;
528    /// Specify at most one of (branch, commit).
529    /// If neither is specified, branch = "main" is the default.
530    #[endpoint(
531        method = GET,
532        path = "/scout/v1/checklists/{rid}",
533        name = "get",
534        accept = conjure_http::client::StdResponseDeserializer
535    )]
536    async fn get(
537        &self,
538        #[auth]
539        auth_: &conjure_object::BearerToken,
540        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
541        rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
542        #[query(
543            name = "branch",
544            encoder = conjure_http::client::conjure::PlainSeqEncoder
545        )]
546        branch: Option<
547            &super::super::super::super::super::objects::scout::versioning::api::BranchName,
548        >,
549        #[query(
550            name = "commit",
551            encoder = conjure_http::client::conjure::PlainSeqEncoder
552        )]
553        commit: Option<
554            &super::super::super::super::super::objects::scout::versioning::api::CommitId,
555        >,
556    ) -> Result<
557        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
558        conjure_http::private::Error,
559    >;
560    /// Returns the pinned commit for each provided checklist reference.
561    #[endpoint(
562        method = POST,
563        path = "/scout/v1/checklists/batch-get",
564        name = "batchGet",
565        accept = conjure_http::client::conjure::CollectionResponseDeserializer
566    )]
567    async fn batch_get(
568        &self,
569        #[auth]
570        auth_: &conjure_object::BearerToken,
571        #[body(serializer = conjure_http::client::StdRequestSerializer)]
572        checklist_refs: &std::collections::BTreeSet<
573            super::super::super::super::super::objects::scout::checks::api::PinnedChecklistRef,
574        >,
575    ) -> Result<
576        std::collections::BTreeSet<
577            super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
578        >,
579        conjure_http::private::Error,
580    >;
581    /// Returns the metadata for each provided checklist.
582    #[endpoint(
583        method = POST,
584        path = "/scout/v1/checklists/batch-get-metadata",
585        name = "batchGetMetadata",
586        accept = conjure_http::client::StdResponseDeserializer
587    )]
588    async fn batch_get_metadata(
589        &self,
590        #[auth]
591        auth_: &conjure_object::BearerToken,
592        #[body(serializer = conjure_http::client::StdRequestSerializer)]
593        request: &super::super::super::super::super::objects::scout::checks::api::BatchGetChecklistMetadataRequest,
594    ) -> Result<
595        super::super::super::super::super::objects::scout::checks::api::BatchGetChecklistMetadataResponse,
596        conjure_http::private::Error,
597    >;
598    /// Results will be the latest commit on main for each checklist.
599    #[endpoint(
600        method = POST,
601        path = "/scout/v1/checklists/search",
602        name = "search",
603        accept = conjure_http::client::StdResponseDeserializer
604    )]
605    async fn search(
606        &self,
607        #[auth]
608        auth_: &conjure_object::BearerToken,
609        #[body(serializer = conjure_http::client::StdRequestSerializer)]
610        request: &super::super::super::super::super::objects::scout::checks::api::SearchChecklistsRequest,
611    ) -> Result<
612        super::super::super::super::super::objects::scout::checks::api::VersionedChecklistPage,
613        conjure_http::private::Error,
614    >;
615    /// Archives the provided checklists.
616    #[endpoint(
617        method = POST,
618        path = "/scout/v1/checklists/archive",
619        name = "archive",
620        accept = conjure_http::client::conjure::EmptyResponseDeserializer
621    )]
622    async fn archive(
623        &self,
624        #[auth]
625        auth_: &conjure_object::BearerToken,
626        #[body(serializer = conjure_http::client::StdRequestSerializer)]
627        request: &super::super::super::super::super::objects::scout::checks::api::ArchiveChecklistsRequest,
628    ) -> Result<(), conjure_http::private::Error>;
629    /// Unarchives the provided checklists.
630    #[endpoint(
631        method = POST,
632        path = "/scout/v1/checklists/unarchive",
633        name = "unarchive",
634        accept = conjure_http::client::conjure::EmptyResponseDeserializer
635    )]
636    async fn unarchive(
637        &self,
638        #[auth]
639        auth_: &conjure_object::BearerToken,
640        #[body(serializer = conjure_http::client::StdRequestSerializer)]
641        request: &super::super::super::super::super::objects::scout::checks::api::UnarchiveChecklistsRequest,
642    ) -> Result<(), conjure_http::private::Error>;
643    /// Returns the check with the given rid.
644    #[endpoint(
645        method = GET,
646        path = "/scout/v1/checklists/check/{rid}",
647        name = "getCheck",
648        accept = conjure_http::client::StdResponseDeserializer
649    )]
650    async fn get_check(
651        &self,
652        #[auth]
653        auth_: &conjure_object::BearerToken,
654        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
655        rid: &super::super::super::super::super::objects::scout::rids::api::CheckRid,
656    ) -> Result<
657        super::super::super::super::super::objects::scout::checks::api::Check,
658        conjure_http::private::Error,
659    >;
660    /// Returns the checks with the given rids.
661    #[endpoint(
662        method = POST,
663        path = "/scout/v1/checklists/check/batch-get",
664        name = "batchGetChecks",
665        accept = conjure_http::client::conjure::CollectionResponseDeserializer
666    )]
667    async fn batch_get_checks(
668        &self,
669        #[auth]
670        auth_: &conjure_object::BearerToken,
671        #[body(serializer = conjure_http::client::StdRequestSerializer)]
672        rids: &std::collections::BTreeSet<
673            super::super::super::super::super::objects::scout::rids::api::CheckRid,
674        >,
675    ) -> Result<
676        std::collections::BTreeSet<
677            super::super::super::super::super::objects::scout::checks::api::Check,
678        >,
679        conjure_http::private::Error,
680    >;
681    /// Returns all labels and properties.
682    #[endpoint(
683        method = GET,
684        path = "/scout/v1/checklists/get-all-labels-properties",
685        name = "getAllLabelsAndProperties",
686        accept = conjure_http::client::StdResponseDeserializer
687    )]
688    async fn get_all_labels_and_properties(
689        &self,
690        #[auth]
691        auth_: &conjure_object::BearerToken,
692        #[query(
693            name = "workspaces",
694            encoder = conjure_http::client::conjure::PlainSeqEncoder
695        )]
696        workspaces: &std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
697    ) -> Result<
698        super::super::super::super::super::objects::scout::checks::api::GetAllLabelsAndPropertiesResponse,
699        conjure_http::private::Error,
700    >;
701    /// Batch edits metadata across multiple checklists. Supports rename/merge for labels and properties.
702    /// If more than 1000 checklists are targeted, this endpoint will throw a 400.
703    #[endpoint(
704        method = POST,
705        path = "/scout/v1/checklists/metadata/batch-edit",
706        name = "batchEditChecklistMetadata",
707        accept = conjure_http::client::StdResponseDeserializer
708    )]
709    async fn batch_edit_checklist_metadata(
710        &self,
711        #[auth]
712        auth_: &conjure_object::BearerToken,
713        #[body(serializer = conjure_http::client::StdRequestSerializer)]
714        request: &super::super::super::super::super::objects::scout::checks::api::BatchEditChecklistMetadataRequest,
715    ) -> Result<
716        super::super::super::super::super::objects::scout::checks::api::BatchEditChecklistMetadataResponse,
717        conjure_http::private::Error,
718    >;
719}
720/// The Checklist Service is responsible for managing checklists and checks.
721/// A checklist is a collection of checks that can be executed against a set of data sources.
722#[conjure_http::conjure_client(name = "ChecklistService", local)]
723pub trait LocalAsyncChecklistService<
724    #[response_body]
725    I: conjure_http::private::Stream<
726            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
727        >,
728> {
729    /// Creates a new checklist with the provided checks.
730    #[endpoint(
731        method = POST,
732        path = "/scout/v1/checklists",
733        name = "create",
734        accept = conjure_http::client::StdResponseDeserializer
735    )]
736    async fn create(
737        &self,
738        #[auth]
739        auth_: &conjure_object::BearerToken,
740        #[body(serializer = conjure_http::client::StdRequestSerializer)]
741        request: &super::super::super::super::super::objects::scout::checks::api::CreateChecklistRequest,
742    ) -> Result<
743        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
744        conjure_http::private::Error,
745    >;
746    /// Creates a permanent commit with a commit message.
747    /// Throws if the checklist or branch doesn't exist.
748    /// Throws if the latest commit doesn't match the provided id.
749    /// Throws if you commit to an archived checklist.
750    #[endpoint(
751        method = POST,
752        path = "/scout/v1/checklists/{checklistRid}/commit",
753        name = "commit",
754        accept = conjure_http::client::StdResponseDeserializer
755    )]
756    async fn commit(
757        &self,
758        #[auth]
759        auth_: &conjure_object::BearerToken,
760        #[path(
761            name = "checklistRid",
762            encoder = conjure_http::client::conjure::PlainEncoder
763        )]
764        checklist_rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
765        #[query(
766            name = "branch",
767            encoder = conjure_http::client::conjure::PlainSeqEncoder
768        )]
769        branch: Option<
770            &super::super::super::super::super::objects::scout::versioning::api::BranchName,
771        >,
772        #[body(serializer = conjure_http::client::StdRequestSerializer)]
773        request: &super::super::super::super::super::objects::scout::checks::api::CommitChecklistRequest,
774    ) -> Result<
775        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
776        conjure_http::private::Error,
777    >;
778    /// Creates a commit that may be compacted, e.g cleaned up and not exist anymore.
779    /// Throws if the checklist or branch doesn't exist.
780    /// Throws if the latest commit doesn't match the provided id.
781    /// Throws if you save to an archived checklist.
782    #[endpoint(
783        method = POST,
784        path = "/scout/v1/checklists/{checklistRid}/save-working-state",
785        name = "saveWorkingState",
786        accept = conjure_http::client::StdResponseDeserializer
787    )]
788    async fn save_working_state(
789        &self,
790        #[auth]
791        auth_: &conjure_object::BearerToken,
792        #[path(
793            name = "checklistRid",
794            encoder = conjure_http::client::conjure::PlainEncoder
795        )]
796        checklist_rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
797        #[query(
798            name = "branch",
799            encoder = conjure_http::client::conjure::PlainSeqEncoder
800        )]
801        branch: Option<
802            &super::super::super::super::super::objects::scout::versioning::api::BranchName,
803        >,
804        #[body(serializer = conjure_http::client::StdRequestSerializer)]
805        request: &super::super::super::super::super::objects::scout::checks::api::SaveChecklistRequest,
806    ) -> Result<
807        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
808        conjure_http::private::Error,
809    >;
810    /// Merges the given branch to the "main" branch.
811    /// Throws if the checklist or branch doesn't exist.
812    /// Throws if the latest commit doesn't match the provided id.
813    /// Throws if you merge with an archived checklist.
814    #[endpoint(
815        method = POST,
816        path = "/scout/v1/checklists/{checklistRid}/merge-to-main",
817        name = "mergeToMain",
818        accept = conjure_http::client::StdResponseDeserializer
819    )]
820    async fn merge_to_main(
821        &self,
822        #[auth]
823        auth_: &conjure_object::BearerToken,
824        #[path(
825            name = "checklistRid",
826            encoder = conjure_http::client::conjure::PlainEncoder
827        )]
828        checklist_rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
829        #[body(serializer = conjure_http::client::StdRequestSerializer)]
830        request: &super::super::super::super::super::objects::scout::checks::api::MergeToMainRequest,
831    ) -> Result<
832        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
833        conjure_http::private::Error,
834    >;
835    /// Updates the data source ref names for all checks within a checklist.
836    /// Throws if the checklist doesn't exist.
837    #[endpoint(
838        method = POST,
839        path = "/scout/v1/checklists/{checklistRid}/update-ref-names",
840        name = "updateDataSourceRefNames",
841        accept = conjure_http::client::StdResponseDeserializer
842    )]
843    async fn update_data_source_ref_names(
844        &self,
845        #[auth]
846        auth_: &conjure_object::BearerToken,
847        #[path(
848            name = "checklistRid",
849            encoder = conjure_http::client::conjure::PlainEncoder
850        )]
851        checklist_rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
852        #[query(
853            name = "branch",
854            encoder = conjure_http::client::conjure::PlainSeqEncoder
855        )]
856        branch: Option<
857            &super::super::super::super::super::objects::scout::versioning::api::BranchName,
858        >,
859        #[body(serializer = conjure_http::client::StdRequestSerializer)]
860        ref_name_updates: &std::collections::BTreeMap<
861            super::super::super::super::super::objects::scout::api::DataSourceRefName,
862            super::super::super::super::super::objects::scout::api::DataSourceRefName,
863        >,
864    ) -> Result<
865        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
866        conjure_http::private::Error,
867    >;
868    /// Updates the metadata of a checklist.
869    #[endpoint(
870        method = PUT,
871        path = "/scout/v1/checklists/{rid}/update-metadata",
872        name = "updateMetadata",
873        accept = conjure_http::client::StdResponseDeserializer
874    )]
875    async fn update_metadata(
876        &self,
877        #[auth]
878        auth_: &conjure_object::BearerToken,
879        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
880        rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
881        #[body(serializer = conjure_http::client::StdRequestSerializer)]
882        request: &super::super::super::super::super::objects::scout::checks::api::UpdateChecklistMetadataRequest,
883    ) -> Result<
884        super::super::super::super::super::objects::scout::checks::api::ChecklistMetadata,
885        conjure_http::private::Error,
886    >;
887    /// Specify at most one of (branch, commit).
888    /// If neither is specified, branch = "main" is the default.
889    #[endpoint(
890        method = GET,
891        path = "/scout/v1/checklists/{rid}",
892        name = "get",
893        accept = conjure_http::client::StdResponseDeserializer
894    )]
895    async fn get(
896        &self,
897        #[auth]
898        auth_: &conjure_object::BearerToken,
899        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
900        rid: &super::super::super::super::super::objects::scout::rids::api::ChecklistRid,
901        #[query(
902            name = "branch",
903            encoder = conjure_http::client::conjure::PlainSeqEncoder
904        )]
905        branch: Option<
906            &super::super::super::super::super::objects::scout::versioning::api::BranchName,
907        >,
908        #[query(
909            name = "commit",
910            encoder = conjure_http::client::conjure::PlainSeqEncoder
911        )]
912        commit: Option<
913            &super::super::super::super::super::objects::scout::versioning::api::CommitId,
914        >,
915    ) -> Result<
916        super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
917        conjure_http::private::Error,
918    >;
919    /// Returns the pinned commit for each provided checklist reference.
920    #[endpoint(
921        method = POST,
922        path = "/scout/v1/checklists/batch-get",
923        name = "batchGet",
924        accept = conjure_http::client::conjure::CollectionResponseDeserializer
925    )]
926    async fn batch_get(
927        &self,
928        #[auth]
929        auth_: &conjure_object::BearerToken,
930        #[body(serializer = conjure_http::client::StdRequestSerializer)]
931        checklist_refs: &std::collections::BTreeSet<
932            super::super::super::super::super::objects::scout::checks::api::PinnedChecklistRef,
933        >,
934    ) -> Result<
935        std::collections::BTreeSet<
936            super::super::super::super::super::objects::scout::checks::api::VersionedChecklist,
937        >,
938        conjure_http::private::Error,
939    >;
940    /// Returns the metadata for each provided checklist.
941    #[endpoint(
942        method = POST,
943        path = "/scout/v1/checklists/batch-get-metadata",
944        name = "batchGetMetadata",
945        accept = conjure_http::client::StdResponseDeserializer
946    )]
947    async fn batch_get_metadata(
948        &self,
949        #[auth]
950        auth_: &conjure_object::BearerToken,
951        #[body(serializer = conjure_http::client::StdRequestSerializer)]
952        request: &super::super::super::super::super::objects::scout::checks::api::BatchGetChecklistMetadataRequest,
953    ) -> Result<
954        super::super::super::super::super::objects::scout::checks::api::BatchGetChecklistMetadataResponse,
955        conjure_http::private::Error,
956    >;
957    /// Results will be the latest commit on main for each checklist.
958    #[endpoint(
959        method = POST,
960        path = "/scout/v1/checklists/search",
961        name = "search",
962        accept = conjure_http::client::StdResponseDeserializer
963    )]
964    async fn search(
965        &self,
966        #[auth]
967        auth_: &conjure_object::BearerToken,
968        #[body(serializer = conjure_http::client::StdRequestSerializer)]
969        request: &super::super::super::super::super::objects::scout::checks::api::SearchChecklistsRequest,
970    ) -> Result<
971        super::super::super::super::super::objects::scout::checks::api::VersionedChecklistPage,
972        conjure_http::private::Error,
973    >;
974    /// Archives the provided checklists.
975    #[endpoint(
976        method = POST,
977        path = "/scout/v1/checklists/archive",
978        name = "archive",
979        accept = conjure_http::client::conjure::EmptyResponseDeserializer
980    )]
981    async fn archive(
982        &self,
983        #[auth]
984        auth_: &conjure_object::BearerToken,
985        #[body(serializer = conjure_http::client::StdRequestSerializer)]
986        request: &super::super::super::super::super::objects::scout::checks::api::ArchiveChecklistsRequest,
987    ) -> Result<(), conjure_http::private::Error>;
988    /// Unarchives the provided checklists.
989    #[endpoint(
990        method = POST,
991        path = "/scout/v1/checklists/unarchive",
992        name = "unarchive",
993        accept = conjure_http::client::conjure::EmptyResponseDeserializer
994    )]
995    async fn unarchive(
996        &self,
997        #[auth]
998        auth_: &conjure_object::BearerToken,
999        #[body(serializer = conjure_http::client::StdRequestSerializer)]
1000        request: &super::super::super::super::super::objects::scout::checks::api::UnarchiveChecklistsRequest,
1001    ) -> Result<(), conjure_http::private::Error>;
1002    /// Returns the check with the given rid.
1003    #[endpoint(
1004        method = GET,
1005        path = "/scout/v1/checklists/check/{rid}",
1006        name = "getCheck",
1007        accept = conjure_http::client::StdResponseDeserializer
1008    )]
1009    async fn get_check(
1010        &self,
1011        #[auth]
1012        auth_: &conjure_object::BearerToken,
1013        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
1014        rid: &super::super::super::super::super::objects::scout::rids::api::CheckRid,
1015    ) -> Result<
1016        super::super::super::super::super::objects::scout::checks::api::Check,
1017        conjure_http::private::Error,
1018    >;
1019    /// Returns the checks with the given rids.
1020    #[endpoint(
1021        method = POST,
1022        path = "/scout/v1/checklists/check/batch-get",
1023        name = "batchGetChecks",
1024        accept = conjure_http::client::conjure::CollectionResponseDeserializer
1025    )]
1026    async fn batch_get_checks(
1027        &self,
1028        #[auth]
1029        auth_: &conjure_object::BearerToken,
1030        #[body(serializer = conjure_http::client::StdRequestSerializer)]
1031        rids: &std::collections::BTreeSet<
1032            super::super::super::super::super::objects::scout::rids::api::CheckRid,
1033        >,
1034    ) -> Result<
1035        std::collections::BTreeSet<
1036            super::super::super::super::super::objects::scout::checks::api::Check,
1037        >,
1038        conjure_http::private::Error,
1039    >;
1040    /// Returns all labels and properties.
1041    #[endpoint(
1042        method = GET,
1043        path = "/scout/v1/checklists/get-all-labels-properties",
1044        name = "getAllLabelsAndProperties",
1045        accept = conjure_http::client::StdResponseDeserializer
1046    )]
1047    async fn get_all_labels_and_properties(
1048        &self,
1049        #[auth]
1050        auth_: &conjure_object::BearerToken,
1051        #[query(
1052            name = "workspaces",
1053            encoder = conjure_http::client::conjure::PlainSeqEncoder
1054        )]
1055        workspaces: &std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
1056    ) -> Result<
1057        super::super::super::super::super::objects::scout::checks::api::GetAllLabelsAndPropertiesResponse,
1058        conjure_http::private::Error,
1059    >;
1060    /// Batch edits metadata across multiple checklists. Supports rename/merge for labels and properties.
1061    /// If more than 1000 checklists are targeted, this endpoint will throw a 400.
1062    #[endpoint(
1063        method = POST,
1064        path = "/scout/v1/checklists/metadata/batch-edit",
1065        name = "batchEditChecklistMetadata",
1066        accept = conjure_http::client::StdResponseDeserializer
1067    )]
1068    async fn batch_edit_checklist_metadata(
1069        &self,
1070        #[auth]
1071        auth_: &conjure_object::BearerToken,
1072        #[body(serializer = conjure_http::client::StdRequestSerializer)]
1073        request: &super::super::super::super::super::objects::scout::checks::api::BatchEditChecklistMetadataRequest,
1074    ) -> Result<
1075        super::super::super::super::super::objects::scout::checks::api::BatchEditChecklistMetadataResponse,
1076        conjure_http::private::Error,
1077    >;
1078}