Skip to main content

nominal_api/conjure/endpoints/secrets/api/
secret_service.rs

1use conjure_http::endpoint;
2/// The secrets service provides functionality for creating and retrieving customer secrets (e.g. influx passwords, API keys, etc)
3#[conjure_http::conjure_endpoints(
4    name = "SecretService",
5    use_legacy_error_serialization
6)]
7pub trait SecretService {
8    /// Create a new secret.
9    #[endpoint(
10        method = POST,
11        path = "/secrets/v1/secrets",
12        name = "create",
13        produces = conjure_http::server::StdResponseSerializer
14    )]
15    fn create(
16        &self,
17        #[auth]
18        auth_: conjure_object::BearerToken,
19        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
20        request: super::super::super::super::objects::secrets::api::CreateSecretRequest,
21    ) -> Result<
22        super::super::super::super::objects::secrets::api::Secret,
23        conjure_http::private::Error,
24    >;
25    /// Get secret by rid.
26    #[endpoint(
27        method = GET,
28        path = "/secrets/v1/secrets/{rid}",
29        name = "get",
30        produces = conjure_http::server::StdResponseSerializer
31    )]
32    fn get(
33        &self,
34        #[auth]
35        auth_: conjure_object::BearerToken,
36        #[path(
37            name = "rid",
38            decoder = conjure_http::server::conjure::FromPlainDecoder,
39            safe
40        )]
41        rid: super::super::super::super::objects::secrets::api::SecretRid,
42    ) -> Result<
43        super::super::super::super::objects::secrets::api::Secret,
44        conjure_http::private::Error,
45    >;
46    /// Get secrets by a set of rids.
47    #[endpoint(
48        method = POST,
49        path = "/secrets/v1/secrets/batch",
50        name = "getBatch",
51        produces = conjure_http::server::StdResponseSerializer
52    )]
53    fn get_batch(
54        &self,
55        #[auth]
56        auth_: conjure_object::BearerToken,
57        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
58        request: super::super::super::super::objects::secrets::api::GetSecretsRequest,
59    ) -> Result<
60        super::super::super::super::objects::secrets::api::GetSecretsResponse,
61        conjure_http::private::Error,
62    >;
63    /// Update a secret by rid.
64    #[endpoint(
65        method = PUT,
66        path = "/secrets/v1/secrets/{rid}",
67        name = "update",
68        produces = conjure_http::server::StdResponseSerializer
69    )]
70    fn update(
71        &self,
72        #[auth]
73        auth_: conjure_object::BearerToken,
74        #[path(
75            name = "rid",
76            decoder = conjure_http::server::conjure::FromPlainDecoder,
77            safe
78        )]
79        rid: super::super::super::super::objects::secrets::api::SecretRid,
80        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
81        request: super::super::super::super::objects::secrets::api::UpdateSecretRequest,
82    ) -> Result<
83        super::super::super::super::objects::secrets::api::Secret,
84        conjure_http::private::Error,
85    >;
86    /// Delete a secret by rid. This is a permanent deletion. To perform a soft delete,
87    /// use the archive endpoint.
88    #[endpoint(method = DELETE, path = "/secrets/v1/secrets/{rid}", name = "delete")]
89    fn delete(
90        &self,
91        #[auth]
92        auth_: conjure_object::BearerToken,
93        #[path(
94            name = "rid",
95            decoder = conjure_http::server::conjure::FromPlainDecoder,
96            safe
97        )]
98        rid: super::super::super::super::objects::secrets::api::SecretRid,
99    ) -> Result<(), conjure_http::private::Error>;
100    /// Archive a secret by rid.
101    #[endpoint(
102        method = PUT,
103        path = "/secrets/v1/secrets/{rid}/archive",
104        name = "archive"
105    )]
106    fn archive(
107        &self,
108        #[auth]
109        auth_: conjure_object::BearerToken,
110        #[path(
111            name = "rid",
112            decoder = conjure_http::server::conjure::FromPlainDecoder,
113            safe
114        )]
115        rid: super::super::super::super::objects::secrets::api::SecretRid,
116    ) -> Result<(), conjure_http::private::Error>;
117    /// Unarchive a secret by rid.
118    #[endpoint(
119        method = PUT,
120        path = "/secrets/v1/secrets/{rid}/unarchive",
121        name = "unarchive"
122    )]
123    fn unarchive(
124        &self,
125        #[auth]
126        auth_: conjure_object::BearerToken,
127        #[path(
128            name = "rid",
129            decoder = conjure_http::server::conjure::FromPlainDecoder,
130            safe
131        )]
132        rid: super::super::super::super::objects::secrets::api::SecretRid,
133    ) -> Result<(), conjure_http::private::Error>;
134    /// Returns metadata about secrets that match a given query.
135    #[endpoint(
136        method = POST,
137        path = "/secrets/v1/secrets/search",
138        name = "search",
139        produces = conjure_http::server::StdResponseSerializer
140    )]
141    fn search(
142        &self,
143        #[auth]
144        auth_: conjure_object::BearerToken,
145        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
146        request: super::super::super::super::objects::secrets::api::SearchSecretsRequest,
147    ) -> Result<
148        super::super::super::super::objects::secrets::api::SearchSecretsResponse,
149        conjure_http::private::Error,
150    >;
151}
152/// The secrets service provides functionality for creating and retrieving customer secrets (e.g. influx passwords, API keys, etc)
153#[conjure_http::conjure_endpoints(
154    name = "SecretService",
155    use_legacy_error_serialization
156)]
157pub trait AsyncSecretService {
158    /// Create a new secret.
159    #[endpoint(
160        method = POST,
161        path = "/secrets/v1/secrets",
162        name = "create",
163        produces = conjure_http::server::StdResponseSerializer
164    )]
165    async fn create(
166        &self,
167        #[auth]
168        auth_: conjure_object::BearerToken,
169        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
170        request: super::super::super::super::objects::secrets::api::CreateSecretRequest,
171    ) -> Result<
172        super::super::super::super::objects::secrets::api::Secret,
173        conjure_http::private::Error,
174    >;
175    /// Get secret by rid.
176    #[endpoint(
177        method = GET,
178        path = "/secrets/v1/secrets/{rid}",
179        name = "get",
180        produces = conjure_http::server::StdResponseSerializer
181    )]
182    async fn get(
183        &self,
184        #[auth]
185        auth_: conjure_object::BearerToken,
186        #[path(
187            name = "rid",
188            decoder = conjure_http::server::conjure::FromPlainDecoder,
189            safe
190        )]
191        rid: super::super::super::super::objects::secrets::api::SecretRid,
192    ) -> Result<
193        super::super::super::super::objects::secrets::api::Secret,
194        conjure_http::private::Error,
195    >;
196    /// Get secrets by a set of rids.
197    #[endpoint(
198        method = POST,
199        path = "/secrets/v1/secrets/batch",
200        name = "getBatch",
201        produces = conjure_http::server::StdResponseSerializer
202    )]
203    async fn get_batch(
204        &self,
205        #[auth]
206        auth_: conjure_object::BearerToken,
207        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
208        request: super::super::super::super::objects::secrets::api::GetSecretsRequest,
209    ) -> Result<
210        super::super::super::super::objects::secrets::api::GetSecretsResponse,
211        conjure_http::private::Error,
212    >;
213    /// Update a secret by rid.
214    #[endpoint(
215        method = PUT,
216        path = "/secrets/v1/secrets/{rid}",
217        name = "update",
218        produces = conjure_http::server::StdResponseSerializer
219    )]
220    async fn update(
221        &self,
222        #[auth]
223        auth_: conjure_object::BearerToken,
224        #[path(
225            name = "rid",
226            decoder = conjure_http::server::conjure::FromPlainDecoder,
227            safe
228        )]
229        rid: super::super::super::super::objects::secrets::api::SecretRid,
230        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
231        request: super::super::super::super::objects::secrets::api::UpdateSecretRequest,
232    ) -> Result<
233        super::super::super::super::objects::secrets::api::Secret,
234        conjure_http::private::Error,
235    >;
236    /// Delete a secret by rid. This is a permanent deletion. To perform a soft delete,
237    /// use the archive endpoint.
238    #[endpoint(method = DELETE, path = "/secrets/v1/secrets/{rid}", name = "delete")]
239    async fn delete(
240        &self,
241        #[auth]
242        auth_: conjure_object::BearerToken,
243        #[path(
244            name = "rid",
245            decoder = conjure_http::server::conjure::FromPlainDecoder,
246            safe
247        )]
248        rid: super::super::super::super::objects::secrets::api::SecretRid,
249    ) -> Result<(), conjure_http::private::Error>;
250    /// Archive a secret by rid.
251    #[endpoint(
252        method = PUT,
253        path = "/secrets/v1/secrets/{rid}/archive",
254        name = "archive"
255    )]
256    async fn archive(
257        &self,
258        #[auth]
259        auth_: conjure_object::BearerToken,
260        #[path(
261            name = "rid",
262            decoder = conjure_http::server::conjure::FromPlainDecoder,
263            safe
264        )]
265        rid: super::super::super::super::objects::secrets::api::SecretRid,
266    ) -> Result<(), conjure_http::private::Error>;
267    /// Unarchive a secret by rid.
268    #[endpoint(
269        method = PUT,
270        path = "/secrets/v1/secrets/{rid}/unarchive",
271        name = "unarchive"
272    )]
273    async fn unarchive(
274        &self,
275        #[auth]
276        auth_: conjure_object::BearerToken,
277        #[path(
278            name = "rid",
279            decoder = conjure_http::server::conjure::FromPlainDecoder,
280            safe
281        )]
282        rid: super::super::super::super::objects::secrets::api::SecretRid,
283    ) -> Result<(), conjure_http::private::Error>;
284    /// Returns metadata about secrets that match a given query.
285    #[endpoint(
286        method = POST,
287        path = "/secrets/v1/secrets/search",
288        name = "search",
289        produces = conjure_http::server::StdResponseSerializer
290    )]
291    async fn search(
292        &self,
293        #[auth]
294        auth_: conjure_object::BearerToken,
295        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
296        request: super::super::super::super::objects::secrets::api::SearchSecretsRequest,
297    ) -> Result<
298        super::super::super::super::objects::secrets::api::SearchSecretsResponse,
299        conjure_http::private::Error,
300    >;
301}
302/// The secrets service provides functionality for creating and retrieving customer secrets (e.g. influx passwords, API keys, etc)
303#[conjure_http::conjure_endpoints(
304    name = "SecretService",
305    use_legacy_error_serialization,
306    local
307)]
308pub trait LocalAsyncSecretService {
309    /// Create a new secret.
310    #[endpoint(
311        method = POST,
312        path = "/secrets/v1/secrets",
313        name = "create",
314        produces = conjure_http::server::StdResponseSerializer
315    )]
316    async fn create(
317        &self,
318        #[auth]
319        auth_: conjure_object::BearerToken,
320        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
321        request: super::super::super::super::objects::secrets::api::CreateSecretRequest,
322    ) -> Result<
323        super::super::super::super::objects::secrets::api::Secret,
324        conjure_http::private::Error,
325    >;
326    /// Get secret by rid.
327    #[endpoint(
328        method = GET,
329        path = "/secrets/v1/secrets/{rid}",
330        name = "get",
331        produces = conjure_http::server::StdResponseSerializer
332    )]
333    async fn get(
334        &self,
335        #[auth]
336        auth_: conjure_object::BearerToken,
337        #[path(
338            name = "rid",
339            decoder = conjure_http::server::conjure::FromPlainDecoder,
340            safe
341        )]
342        rid: super::super::super::super::objects::secrets::api::SecretRid,
343    ) -> Result<
344        super::super::super::super::objects::secrets::api::Secret,
345        conjure_http::private::Error,
346    >;
347    /// Get secrets by a set of rids.
348    #[endpoint(
349        method = POST,
350        path = "/secrets/v1/secrets/batch",
351        name = "getBatch",
352        produces = conjure_http::server::StdResponseSerializer
353    )]
354    async fn get_batch(
355        &self,
356        #[auth]
357        auth_: conjure_object::BearerToken,
358        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
359        request: super::super::super::super::objects::secrets::api::GetSecretsRequest,
360    ) -> Result<
361        super::super::super::super::objects::secrets::api::GetSecretsResponse,
362        conjure_http::private::Error,
363    >;
364    /// Update a secret by rid.
365    #[endpoint(
366        method = PUT,
367        path = "/secrets/v1/secrets/{rid}",
368        name = "update",
369        produces = conjure_http::server::StdResponseSerializer
370    )]
371    async fn update(
372        &self,
373        #[auth]
374        auth_: conjure_object::BearerToken,
375        #[path(
376            name = "rid",
377            decoder = conjure_http::server::conjure::FromPlainDecoder,
378            safe
379        )]
380        rid: super::super::super::super::objects::secrets::api::SecretRid,
381        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
382        request: super::super::super::super::objects::secrets::api::UpdateSecretRequest,
383    ) -> Result<
384        super::super::super::super::objects::secrets::api::Secret,
385        conjure_http::private::Error,
386    >;
387    /// Delete a secret by rid. This is a permanent deletion. To perform a soft delete,
388    /// use the archive endpoint.
389    #[endpoint(method = DELETE, path = "/secrets/v1/secrets/{rid}", name = "delete")]
390    async fn delete(
391        &self,
392        #[auth]
393        auth_: conjure_object::BearerToken,
394        #[path(
395            name = "rid",
396            decoder = conjure_http::server::conjure::FromPlainDecoder,
397            safe
398        )]
399        rid: super::super::super::super::objects::secrets::api::SecretRid,
400    ) -> Result<(), conjure_http::private::Error>;
401    /// Archive a secret by rid.
402    #[endpoint(
403        method = PUT,
404        path = "/secrets/v1/secrets/{rid}/archive",
405        name = "archive"
406    )]
407    async fn archive(
408        &self,
409        #[auth]
410        auth_: conjure_object::BearerToken,
411        #[path(
412            name = "rid",
413            decoder = conjure_http::server::conjure::FromPlainDecoder,
414            safe
415        )]
416        rid: super::super::super::super::objects::secrets::api::SecretRid,
417    ) -> Result<(), conjure_http::private::Error>;
418    /// Unarchive a secret by rid.
419    #[endpoint(
420        method = PUT,
421        path = "/secrets/v1/secrets/{rid}/unarchive",
422        name = "unarchive"
423    )]
424    async fn unarchive(
425        &self,
426        #[auth]
427        auth_: conjure_object::BearerToken,
428        #[path(
429            name = "rid",
430            decoder = conjure_http::server::conjure::FromPlainDecoder,
431            safe
432        )]
433        rid: super::super::super::super::objects::secrets::api::SecretRid,
434    ) -> Result<(), conjure_http::private::Error>;
435    /// Returns metadata about secrets that match a given query.
436    #[endpoint(
437        method = POST,
438        path = "/secrets/v1/secrets/search",
439        name = "search",
440        produces = conjure_http::server::StdResponseSerializer
441    )]
442    async fn search(
443        &self,
444        #[auth]
445        auth_: conjure_object::BearerToken,
446        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
447        request: super::super::super::super::objects::secrets::api::SearchSecretsRequest,
448    ) -> Result<
449        super::super::super::super::objects::secrets::api::SearchSecretsResponse,
450        conjure_http::private::Error,
451    >;
452}