Skip to main content

nominal_api/conjure/clients/scout/integrations/api/
integrations_service.rs

1use conjure_http::endpoint;
2/// Service for managing integrations with external services.
3#[conjure_http::conjure_client(name = "IntegrationsService")]
4pub trait IntegrationsService<
5    #[response_body]
6    I: Iterator<
7            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
8        >,
9> {
10    /// Generates link to request permissions for Slack bot to join workspaces and use a webhook.
11    #[endpoint(
12        method = GET,
13        path = "/scout/v2/integrations/slack-oauth/init-webhook",
14        name = "generateSlackWebhookLink",
15        accept = conjure_http::client::StdResponseDeserializer
16    )]
17    fn generate_slack_webhook_link(
18        &self,
19        #[auth]
20        auth_: &conjure_object::BearerToken,
21        #[query(
22            name = "workspace",
23            encoder = conjure_http::client::conjure::PlainSeqEncoder
24        )]
25        workspace: Option<&conjure_object::ResourceIdentifier>,
26        #[query(
27            name = "isGovSlack",
28            encoder = conjure_http::client::conjure::PlainSeqEncoder
29        )]
30        is_gov_slack: Option<bool>,
31    ) -> Result<
32        super::super::super::super::super::objects::scout::integrations::api::GenerateSlackWebhookResponse,
33        conjure_http::private::Error,
34    >;
35    /// Creates a new Slack integration. Called internally after Slack authorization.
36    #[endpoint(
37        method = GET,
38        path = "/scout/v2/integrations/slack-oauth/redirect",
39        name = "createSlackWebhook",
40        accept = conjure_http::client::conjure::EmptyResponseDeserializer
41    )]
42    fn create_slack_webhook(
43        &self,
44        #[auth]
45        auth_: &conjure_object::BearerToken,
46        #[query(name = "code", encoder = conjure_http::client::conjure::PlainEncoder)]
47        code: &str,
48        #[query(name = "state", encoder = conjure_http::client::conjure::PlainEncoder)]
49        state: &str,
50    ) -> Result<(), conjure_http::private::Error>;
51    /// Creates a new integration.
52    #[endpoint(
53        method = POST,
54        path = "/scout/v2/integrations",
55        name = "createIntegration",
56        accept = conjure_http::client::StdResponseDeserializer
57    )]
58    fn create_integration(
59        &self,
60        #[auth]
61        auth_: &conjure_object::BearerToken,
62        #[body(serializer = conjure_http::client::StdRequestSerializer)]
63        create_integration_request: &super::super::super::super::super::objects::scout::integrations::api::CreateIntegrationRequest,
64    ) -> Result<
65        super::super::super::super::super::objects::scout::integrations::api::Integration,
66        conjure_http::private::Error,
67    >;
68    /// Creates a new webhook integration with HMAC signing.
69    /// Returns the integration and the server-generated signing key.
70    /// The signing key is only returned once — store it securely.
71    #[endpoint(
72        method = POST,
73        path = "/scout/v2/integrations/internal/secure-webhook",
74        name = "createSecureWebhookIntegration",
75        accept = conjure_http::client::StdResponseDeserializer
76    )]
77    fn create_secure_webhook_integration(
78        &self,
79        #[auth]
80        auth_: &conjure_object::BearerToken,
81        #[body(serializer = conjure_http::client::StdRequestSerializer)]
82        request: &super::super::super::super::super::objects::scout::integrations::api::CreateSecureWebhookIntegrationRequest,
83    ) -> Result<
84        super::super::super::super::super::objects::scout::integrations::api::CreateSecureWebhookIntegrationResponse,
85        conjure_http::private::Error,
86    >;
87    /// Sends a message to a secure webhook integration with HMAC-SHA256 signature.
88    /// Implements retry logic with exponential backoff based on merged delivery configuration.
89    /// Request configuration overrides take precedence over integration's stored configuration.
90    #[endpoint(
91        method = POST,
92        path = "/scout/v2/integrations/internal/secure-webhook/{integrationRid}",
93        name = "sendSecureWebhookMessage",
94        accept = conjure_http::client::StdResponseDeserializer
95    )]
96    fn send_secure_webhook_message(
97        &self,
98        #[auth]
99        auth_: &conjure_object::BearerToken,
100        #[path(
101            name = "integrationRid",
102            encoder = conjure_http::client::conjure::PlainEncoder
103        )]
104        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
105        #[body(serializer = conjure_http::client::StdRequestSerializer)]
106        request: &super::super::super::super::super::objects::scout::integrations::api::SendSecureWebhookMessageRequest,
107    ) -> Result<
108        super::super::super::super::super::objects::scout::integrations::api::SendSecureWebhookMessageResponse,
109        conjure_http::private::Error,
110    >;
111    /// Deletes an integration by archiving.
112    #[endpoint(
113        method = DELETE,
114        path = "/scout/v2/integrations/{integrationRid}",
115        name = "deleteIntegration",
116        accept = conjure_http::client::conjure::EmptyResponseDeserializer
117    )]
118    fn delete_integration(
119        &self,
120        #[auth]
121        auth_: &conjure_object::BearerToken,
122        #[path(
123            name = "integrationRid",
124            encoder = conjure_http::client::conjure::PlainEncoder
125        )]
126        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
127    ) -> Result<(), conjure_http::private::Error>;
128    /// Updates the metadata of an integration.
129    #[endpoint(
130        method = PUT,
131        path = "/scout/v2/integrations/{integrationRid}",
132        name = "updateIntegrationMetadata",
133        accept = conjure_http::client::StdResponseDeserializer
134    )]
135    fn update_integration_metadata(
136        &self,
137        #[auth]
138        auth_: &conjure_object::BearerToken,
139        #[path(
140            name = "integrationRid",
141            encoder = conjure_http::client::conjure::PlainEncoder
142        )]
143        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
144        #[body(serializer = conjure_http::client::StdRequestSerializer)]
145        request: &super::super::super::super::super::objects::scout::integrations::api::UpdateIntegrationRequest,
146    ) -> Result<
147        super::super::super::super::super::objects::scout::integrations::api::Integration,
148        conjure_http::private::Error,
149    >;
150    /// Updates the integration details for an integration.
151    /// Intended to allow changing webhooks or rotating API keys.
152    #[endpoint(
153        method = PUT,
154        path = "/scout/v2/integrations/{integrationRid}/details",
155        name = "updateIntegrationDetails",
156        accept = conjure_http::client::StdResponseDeserializer
157    )]
158    fn update_integration_details(
159        &self,
160        #[auth]
161        auth_: &conjure_object::BearerToken,
162        #[path(
163            name = "integrationRid",
164            encoder = conjure_http::client::conjure::PlainEncoder
165        )]
166        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
167        #[body(serializer = conjure_http::client::StdRequestSerializer)]
168        request: &super::super::super::super::super::objects::scout::integrations::api::UpdateIntegrationDetailsRequest,
169    ) -> Result<
170        super::super::super::super::super::objects::scout::integrations::api::Integration,
171        conjure_http::private::Error,
172    >;
173    /// Retrieves an integration with the specified integration RID.
174    #[endpoint(
175        method = GET,
176        path = "/scout/v2/integrations/{integrationRid}",
177        name = "getIntegration",
178        accept = conjure_http::client::StdResponseDeserializer
179    )]
180    fn get_integration(
181        &self,
182        #[auth]
183        auth_: &conjure_object::BearerToken,
184        #[path(
185            name = "integrationRid",
186            encoder = conjure_http::client::conjure::PlainEncoder
187        )]
188        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
189    ) -> Result<
190        super::super::super::super::super::objects::scout::integrations::api::Integration,
191        conjure_http::private::Error,
192    >;
193    /// Lists all integrations. Archived integrations are not included.
194    #[endpoint(
195        method = GET,
196        path = "/scout/v2/integrations/list",
197        name = "listIntegrations",
198        accept = conjure_http::client::conjure::CollectionResponseDeserializer
199    )]
200    fn list_integrations(
201        &self,
202        #[auth]
203        auth_: &conjure_object::BearerToken,
204        #[query(
205            name = "workspaces",
206            encoder = conjure_http::client::conjure::PlainSeqEncoder
207        )]
208        workspaces: &std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
209    ) -> Result<
210        Vec<
211            super::super::super::super::super::objects::scout::integrations::api::Integration,
212        >,
213        conjure_http::private::Error,
214    >;
215    /// Sends a string message to the specified integration from a checklist execution.
216    #[endpoint(
217        method = POST,
218        path = "/scout/v2/integrations/send-message",
219        name = "sendMessage",
220        accept = conjure_http::client::conjure::EmptyResponseDeserializer
221    )]
222    fn send_message(
223        &self,
224        #[auth]
225        auth_: &conjure_object::BearerToken,
226        #[body(serializer = conjure_http::client::StdRequestSerializer)]
227        request: &super::super::super::super::super::objects::scout::integrations::api::SendMessageRequest,
228    ) -> Result<(), conjure_http::private::Error>;
229    /// Rotates the HMAC signing key for a webhook integration.
230    /// The old key is immediately invalidated and a new key is generated and returned.
231    /// This is the only way to retrieve the signing key after initial creation.
232    #[endpoint(
233        method = POST,
234        path = "/scout/v2/integrations/internal/{integrationRid}/rotate-signing-key",
235        name = "rotateSecureWebhookIntegrationSigningKey",
236        accept = conjure_http::client::StdResponseDeserializer
237    )]
238    fn rotate_secure_webhook_integration_signing_key(
239        &self,
240        #[auth]
241        auth_: &conjure_object::BearerToken,
242        #[path(
243            name = "integrationRid",
244            encoder = conjure_http::client::conjure::PlainEncoder
245        )]
246        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
247    ) -> Result<
248        super::super::super::super::super::objects::scout::integrations::api::RotateWebhookSigningKeyResponse,
249        conjure_http::private::Error,
250    >;
251}
252/// Service for managing integrations with external services.
253#[conjure_http::conjure_client(name = "IntegrationsService")]
254pub trait AsyncIntegrationsService<
255    #[response_body]
256    I: conjure_http::private::Stream<
257            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
258        >,
259> {
260    /// Generates link to request permissions for Slack bot to join workspaces and use a webhook.
261    #[endpoint(
262        method = GET,
263        path = "/scout/v2/integrations/slack-oauth/init-webhook",
264        name = "generateSlackWebhookLink",
265        accept = conjure_http::client::StdResponseDeserializer
266    )]
267    async fn generate_slack_webhook_link(
268        &self,
269        #[auth]
270        auth_: &conjure_object::BearerToken,
271        #[query(
272            name = "workspace",
273            encoder = conjure_http::client::conjure::PlainSeqEncoder
274        )]
275        workspace: Option<&conjure_object::ResourceIdentifier>,
276        #[query(
277            name = "isGovSlack",
278            encoder = conjure_http::client::conjure::PlainSeqEncoder
279        )]
280        is_gov_slack: Option<bool>,
281    ) -> Result<
282        super::super::super::super::super::objects::scout::integrations::api::GenerateSlackWebhookResponse,
283        conjure_http::private::Error,
284    >;
285    /// Creates a new Slack integration. Called internally after Slack authorization.
286    #[endpoint(
287        method = GET,
288        path = "/scout/v2/integrations/slack-oauth/redirect",
289        name = "createSlackWebhook",
290        accept = conjure_http::client::conjure::EmptyResponseDeserializer
291    )]
292    async fn create_slack_webhook(
293        &self,
294        #[auth]
295        auth_: &conjure_object::BearerToken,
296        #[query(name = "code", encoder = conjure_http::client::conjure::PlainEncoder)]
297        code: &str,
298        #[query(name = "state", encoder = conjure_http::client::conjure::PlainEncoder)]
299        state: &str,
300    ) -> Result<(), conjure_http::private::Error>;
301    /// Creates a new integration.
302    #[endpoint(
303        method = POST,
304        path = "/scout/v2/integrations",
305        name = "createIntegration",
306        accept = conjure_http::client::StdResponseDeserializer
307    )]
308    async fn create_integration(
309        &self,
310        #[auth]
311        auth_: &conjure_object::BearerToken,
312        #[body(serializer = conjure_http::client::StdRequestSerializer)]
313        create_integration_request: &super::super::super::super::super::objects::scout::integrations::api::CreateIntegrationRequest,
314    ) -> Result<
315        super::super::super::super::super::objects::scout::integrations::api::Integration,
316        conjure_http::private::Error,
317    >;
318    /// Creates a new webhook integration with HMAC signing.
319    /// Returns the integration and the server-generated signing key.
320    /// The signing key is only returned once — store it securely.
321    #[endpoint(
322        method = POST,
323        path = "/scout/v2/integrations/internal/secure-webhook",
324        name = "createSecureWebhookIntegration",
325        accept = conjure_http::client::StdResponseDeserializer
326    )]
327    async fn create_secure_webhook_integration(
328        &self,
329        #[auth]
330        auth_: &conjure_object::BearerToken,
331        #[body(serializer = conjure_http::client::StdRequestSerializer)]
332        request: &super::super::super::super::super::objects::scout::integrations::api::CreateSecureWebhookIntegrationRequest,
333    ) -> Result<
334        super::super::super::super::super::objects::scout::integrations::api::CreateSecureWebhookIntegrationResponse,
335        conjure_http::private::Error,
336    >;
337    /// Sends a message to a secure webhook integration with HMAC-SHA256 signature.
338    /// Implements retry logic with exponential backoff based on merged delivery configuration.
339    /// Request configuration overrides take precedence over integration's stored configuration.
340    #[endpoint(
341        method = POST,
342        path = "/scout/v2/integrations/internal/secure-webhook/{integrationRid}",
343        name = "sendSecureWebhookMessage",
344        accept = conjure_http::client::StdResponseDeserializer
345    )]
346    async fn send_secure_webhook_message(
347        &self,
348        #[auth]
349        auth_: &conjure_object::BearerToken,
350        #[path(
351            name = "integrationRid",
352            encoder = conjure_http::client::conjure::PlainEncoder
353        )]
354        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
355        #[body(serializer = conjure_http::client::StdRequestSerializer)]
356        request: &super::super::super::super::super::objects::scout::integrations::api::SendSecureWebhookMessageRequest,
357    ) -> Result<
358        super::super::super::super::super::objects::scout::integrations::api::SendSecureWebhookMessageResponse,
359        conjure_http::private::Error,
360    >;
361    /// Deletes an integration by archiving.
362    #[endpoint(
363        method = DELETE,
364        path = "/scout/v2/integrations/{integrationRid}",
365        name = "deleteIntegration",
366        accept = conjure_http::client::conjure::EmptyResponseDeserializer
367    )]
368    async fn delete_integration(
369        &self,
370        #[auth]
371        auth_: &conjure_object::BearerToken,
372        #[path(
373            name = "integrationRid",
374            encoder = conjure_http::client::conjure::PlainEncoder
375        )]
376        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
377    ) -> Result<(), conjure_http::private::Error>;
378    /// Updates the metadata of an integration.
379    #[endpoint(
380        method = PUT,
381        path = "/scout/v2/integrations/{integrationRid}",
382        name = "updateIntegrationMetadata",
383        accept = conjure_http::client::StdResponseDeserializer
384    )]
385    async fn update_integration_metadata(
386        &self,
387        #[auth]
388        auth_: &conjure_object::BearerToken,
389        #[path(
390            name = "integrationRid",
391            encoder = conjure_http::client::conjure::PlainEncoder
392        )]
393        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
394        #[body(serializer = conjure_http::client::StdRequestSerializer)]
395        request: &super::super::super::super::super::objects::scout::integrations::api::UpdateIntegrationRequest,
396    ) -> Result<
397        super::super::super::super::super::objects::scout::integrations::api::Integration,
398        conjure_http::private::Error,
399    >;
400    /// Updates the integration details for an integration.
401    /// Intended to allow changing webhooks or rotating API keys.
402    #[endpoint(
403        method = PUT,
404        path = "/scout/v2/integrations/{integrationRid}/details",
405        name = "updateIntegrationDetails",
406        accept = conjure_http::client::StdResponseDeserializer
407    )]
408    async fn update_integration_details(
409        &self,
410        #[auth]
411        auth_: &conjure_object::BearerToken,
412        #[path(
413            name = "integrationRid",
414            encoder = conjure_http::client::conjure::PlainEncoder
415        )]
416        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
417        #[body(serializer = conjure_http::client::StdRequestSerializer)]
418        request: &super::super::super::super::super::objects::scout::integrations::api::UpdateIntegrationDetailsRequest,
419    ) -> Result<
420        super::super::super::super::super::objects::scout::integrations::api::Integration,
421        conjure_http::private::Error,
422    >;
423    /// Retrieves an integration with the specified integration RID.
424    #[endpoint(
425        method = GET,
426        path = "/scout/v2/integrations/{integrationRid}",
427        name = "getIntegration",
428        accept = conjure_http::client::StdResponseDeserializer
429    )]
430    async fn get_integration(
431        &self,
432        #[auth]
433        auth_: &conjure_object::BearerToken,
434        #[path(
435            name = "integrationRid",
436            encoder = conjure_http::client::conjure::PlainEncoder
437        )]
438        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
439    ) -> Result<
440        super::super::super::super::super::objects::scout::integrations::api::Integration,
441        conjure_http::private::Error,
442    >;
443    /// Lists all integrations. Archived integrations are not included.
444    #[endpoint(
445        method = GET,
446        path = "/scout/v2/integrations/list",
447        name = "listIntegrations",
448        accept = conjure_http::client::conjure::CollectionResponseDeserializer
449    )]
450    async fn list_integrations(
451        &self,
452        #[auth]
453        auth_: &conjure_object::BearerToken,
454        #[query(
455            name = "workspaces",
456            encoder = conjure_http::client::conjure::PlainSeqEncoder
457        )]
458        workspaces: &std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
459    ) -> Result<
460        Vec<
461            super::super::super::super::super::objects::scout::integrations::api::Integration,
462        >,
463        conjure_http::private::Error,
464    >;
465    /// Sends a string message to the specified integration from a checklist execution.
466    #[endpoint(
467        method = POST,
468        path = "/scout/v2/integrations/send-message",
469        name = "sendMessage",
470        accept = conjure_http::client::conjure::EmptyResponseDeserializer
471    )]
472    async fn send_message(
473        &self,
474        #[auth]
475        auth_: &conjure_object::BearerToken,
476        #[body(serializer = conjure_http::client::StdRequestSerializer)]
477        request: &super::super::super::super::super::objects::scout::integrations::api::SendMessageRequest,
478    ) -> Result<(), conjure_http::private::Error>;
479    /// Rotates the HMAC signing key for a webhook integration.
480    /// The old key is immediately invalidated and a new key is generated and returned.
481    /// This is the only way to retrieve the signing key after initial creation.
482    #[endpoint(
483        method = POST,
484        path = "/scout/v2/integrations/internal/{integrationRid}/rotate-signing-key",
485        name = "rotateSecureWebhookIntegrationSigningKey",
486        accept = conjure_http::client::StdResponseDeserializer
487    )]
488    async fn rotate_secure_webhook_integration_signing_key(
489        &self,
490        #[auth]
491        auth_: &conjure_object::BearerToken,
492        #[path(
493            name = "integrationRid",
494            encoder = conjure_http::client::conjure::PlainEncoder
495        )]
496        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
497    ) -> Result<
498        super::super::super::super::super::objects::scout::integrations::api::RotateWebhookSigningKeyResponse,
499        conjure_http::private::Error,
500    >;
501}
502/// Service for managing integrations with external services.
503#[conjure_http::conjure_client(name = "IntegrationsService", local)]
504pub trait LocalAsyncIntegrationsService<
505    #[response_body]
506    I: conjure_http::private::Stream<
507            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
508        >,
509> {
510    /// Generates link to request permissions for Slack bot to join workspaces and use a webhook.
511    #[endpoint(
512        method = GET,
513        path = "/scout/v2/integrations/slack-oauth/init-webhook",
514        name = "generateSlackWebhookLink",
515        accept = conjure_http::client::StdResponseDeserializer
516    )]
517    async fn generate_slack_webhook_link(
518        &self,
519        #[auth]
520        auth_: &conjure_object::BearerToken,
521        #[query(
522            name = "workspace",
523            encoder = conjure_http::client::conjure::PlainSeqEncoder
524        )]
525        workspace: Option<&conjure_object::ResourceIdentifier>,
526        #[query(
527            name = "isGovSlack",
528            encoder = conjure_http::client::conjure::PlainSeqEncoder
529        )]
530        is_gov_slack: Option<bool>,
531    ) -> Result<
532        super::super::super::super::super::objects::scout::integrations::api::GenerateSlackWebhookResponse,
533        conjure_http::private::Error,
534    >;
535    /// Creates a new Slack integration. Called internally after Slack authorization.
536    #[endpoint(
537        method = GET,
538        path = "/scout/v2/integrations/slack-oauth/redirect",
539        name = "createSlackWebhook",
540        accept = conjure_http::client::conjure::EmptyResponseDeserializer
541    )]
542    async fn create_slack_webhook(
543        &self,
544        #[auth]
545        auth_: &conjure_object::BearerToken,
546        #[query(name = "code", encoder = conjure_http::client::conjure::PlainEncoder)]
547        code: &str,
548        #[query(name = "state", encoder = conjure_http::client::conjure::PlainEncoder)]
549        state: &str,
550    ) -> Result<(), conjure_http::private::Error>;
551    /// Creates a new integration.
552    #[endpoint(
553        method = POST,
554        path = "/scout/v2/integrations",
555        name = "createIntegration",
556        accept = conjure_http::client::StdResponseDeserializer
557    )]
558    async fn create_integration(
559        &self,
560        #[auth]
561        auth_: &conjure_object::BearerToken,
562        #[body(serializer = conjure_http::client::StdRequestSerializer)]
563        create_integration_request: &super::super::super::super::super::objects::scout::integrations::api::CreateIntegrationRequest,
564    ) -> Result<
565        super::super::super::super::super::objects::scout::integrations::api::Integration,
566        conjure_http::private::Error,
567    >;
568    /// Creates a new webhook integration with HMAC signing.
569    /// Returns the integration and the server-generated signing key.
570    /// The signing key is only returned once — store it securely.
571    #[endpoint(
572        method = POST,
573        path = "/scout/v2/integrations/internal/secure-webhook",
574        name = "createSecureWebhookIntegration",
575        accept = conjure_http::client::StdResponseDeserializer
576    )]
577    async fn create_secure_webhook_integration(
578        &self,
579        #[auth]
580        auth_: &conjure_object::BearerToken,
581        #[body(serializer = conjure_http::client::StdRequestSerializer)]
582        request: &super::super::super::super::super::objects::scout::integrations::api::CreateSecureWebhookIntegrationRequest,
583    ) -> Result<
584        super::super::super::super::super::objects::scout::integrations::api::CreateSecureWebhookIntegrationResponse,
585        conjure_http::private::Error,
586    >;
587    /// Sends a message to a secure webhook integration with HMAC-SHA256 signature.
588    /// Implements retry logic with exponential backoff based on merged delivery configuration.
589    /// Request configuration overrides take precedence over integration's stored configuration.
590    #[endpoint(
591        method = POST,
592        path = "/scout/v2/integrations/internal/secure-webhook/{integrationRid}",
593        name = "sendSecureWebhookMessage",
594        accept = conjure_http::client::StdResponseDeserializer
595    )]
596    async fn send_secure_webhook_message(
597        &self,
598        #[auth]
599        auth_: &conjure_object::BearerToken,
600        #[path(
601            name = "integrationRid",
602            encoder = conjure_http::client::conjure::PlainEncoder
603        )]
604        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
605        #[body(serializer = conjure_http::client::StdRequestSerializer)]
606        request: &super::super::super::super::super::objects::scout::integrations::api::SendSecureWebhookMessageRequest,
607    ) -> Result<
608        super::super::super::super::super::objects::scout::integrations::api::SendSecureWebhookMessageResponse,
609        conjure_http::private::Error,
610    >;
611    /// Deletes an integration by archiving.
612    #[endpoint(
613        method = DELETE,
614        path = "/scout/v2/integrations/{integrationRid}",
615        name = "deleteIntegration",
616        accept = conjure_http::client::conjure::EmptyResponseDeserializer
617    )]
618    async fn delete_integration(
619        &self,
620        #[auth]
621        auth_: &conjure_object::BearerToken,
622        #[path(
623            name = "integrationRid",
624            encoder = conjure_http::client::conjure::PlainEncoder
625        )]
626        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
627    ) -> Result<(), conjure_http::private::Error>;
628    /// Updates the metadata of an integration.
629    #[endpoint(
630        method = PUT,
631        path = "/scout/v2/integrations/{integrationRid}",
632        name = "updateIntegrationMetadata",
633        accept = conjure_http::client::StdResponseDeserializer
634    )]
635    async fn update_integration_metadata(
636        &self,
637        #[auth]
638        auth_: &conjure_object::BearerToken,
639        #[path(
640            name = "integrationRid",
641            encoder = conjure_http::client::conjure::PlainEncoder
642        )]
643        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
644        #[body(serializer = conjure_http::client::StdRequestSerializer)]
645        request: &super::super::super::super::super::objects::scout::integrations::api::UpdateIntegrationRequest,
646    ) -> Result<
647        super::super::super::super::super::objects::scout::integrations::api::Integration,
648        conjure_http::private::Error,
649    >;
650    /// Updates the integration details for an integration.
651    /// Intended to allow changing webhooks or rotating API keys.
652    #[endpoint(
653        method = PUT,
654        path = "/scout/v2/integrations/{integrationRid}/details",
655        name = "updateIntegrationDetails",
656        accept = conjure_http::client::StdResponseDeserializer
657    )]
658    async fn update_integration_details(
659        &self,
660        #[auth]
661        auth_: &conjure_object::BearerToken,
662        #[path(
663            name = "integrationRid",
664            encoder = conjure_http::client::conjure::PlainEncoder
665        )]
666        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
667        #[body(serializer = conjure_http::client::StdRequestSerializer)]
668        request: &super::super::super::super::super::objects::scout::integrations::api::UpdateIntegrationDetailsRequest,
669    ) -> Result<
670        super::super::super::super::super::objects::scout::integrations::api::Integration,
671        conjure_http::private::Error,
672    >;
673    /// Retrieves an integration with the specified integration RID.
674    #[endpoint(
675        method = GET,
676        path = "/scout/v2/integrations/{integrationRid}",
677        name = "getIntegration",
678        accept = conjure_http::client::StdResponseDeserializer
679    )]
680    async fn get_integration(
681        &self,
682        #[auth]
683        auth_: &conjure_object::BearerToken,
684        #[path(
685            name = "integrationRid",
686            encoder = conjure_http::client::conjure::PlainEncoder
687        )]
688        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
689    ) -> Result<
690        super::super::super::super::super::objects::scout::integrations::api::Integration,
691        conjure_http::private::Error,
692    >;
693    /// Lists all integrations. Archived integrations are not included.
694    #[endpoint(
695        method = GET,
696        path = "/scout/v2/integrations/list",
697        name = "listIntegrations",
698        accept = conjure_http::client::conjure::CollectionResponseDeserializer
699    )]
700    async fn list_integrations(
701        &self,
702        #[auth]
703        auth_: &conjure_object::BearerToken,
704        #[query(
705            name = "workspaces",
706            encoder = conjure_http::client::conjure::PlainSeqEncoder
707        )]
708        workspaces: &std::collections::BTreeSet<conjure_object::ResourceIdentifier>,
709    ) -> Result<
710        Vec<
711            super::super::super::super::super::objects::scout::integrations::api::Integration,
712        >,
713        conjure_http::private::Error,
714    >;
715    /// Sends a string message to the specified integration from a checklist execution.
716    #[endpoint(
717        method = POST,
718        path = "/scout/v2/integrations/send-message",
719        name = "sendMessage",
720        accept = conjure_http::client::conjure::EmptyResponseDeserializer
721    )]
722    async fn send_message(
723        &self,
724        #[auth]
725        auth_: &conjure_object::BearerToken,
726        #[body(serializer = conjure_http::client::StdRequestSerializer)]
727        request: &super::super::super::super::super::objects::scout::integrations::api::SendMessageRequest,
728    ) -> Result<(), conjure_http::private::Error>;
729    /// Rotates the HMAC signing key for a webhook integration.
730    /// The old key is immediately invalidated and a new key is generated and returned.
731    /// This is the only way to retrieve the signing key after initial creation.
732    #[endpoint(
733        method = POST,
734        path = "/scout/v2/integrations/internal/{integrationRid}/rotate-signing-key",
735        name = "rotateSecureWebhookIntegrationSigningKey",
736        accept = conjure_http::client::StdResponseDeserializer
737    )]
738    async fn rotate_secure_webhook_integration_signing_key(
739        &self,
740        #[auth]
741        auth_: &conjure_object::BearerToken,
742        #[path(
743            name = "integrationRid",
744            encoder = conjure_http::client::conjure::PlainEncoder
745        )]
746        integration_rid: &super::super::super::super::super::objects::scout::integrations::api::IntegrationRid,
747    ) -> Result<
748        super::super::super::super::super::objects::scout::integrations::api::RotateWebhookSigningKeyResponse,
749        conjure_http::private::Error,
750    >;
751}