Skip to main content

bitwarden_api_api/apis/
emergency_access_api.rs

1/*
2 * Bitwarden Internal API
3 *
4 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5 *
6 * The version of the OpenAPI document: latest
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use std::sync::Arc;
12
13use async_trait::async_trait;
14#[cfg(feature = "mockall")]
15use mockall::automock;
16use reqwest;
17use serde::{Deserialize, Serialize, de::Error as _};
18
19use super::{Error, configuration};
20use crate::{
21    apis::{AuthRequired, ContentType, ResponseContent},
22    models,
23};
24
25#[cfg_attr(feature = "mockall", automock)]
26#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
27#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
28pub trait EmergencyAccessApi: Send + Sync {
29    /// POST /emergency-access/{id}/accept
30    async fn accept<'a>(
31        &self,
32        id: uuid::Uuid,
33        organization_user_accept_request_model: Option<models::OrganizationUserAcceptRequestModel>,
34    ) -> Result<(), Error>;
35
36    /// POST /emergency-access/{id}/approve
37    async fn approve<'a>(&self, id: uuid::Uuid) -> Result<(), Error>;
38
39    /// POST /emergency-access/{id}/confirm
40    async fn confirm<'a>(
41        &self,
42        id: uuid::Uuid,
43        organization_user_confirm_request_model: Option<
44            models::OrganizationUserConfirmRequestModel,
45        >,
46    ) -> Result<(), Error>;
47
48    /// DELETE /emergency-access/{id}
49    async fn delete<'a>(&self, id: uuid::Uuid) -> Result<(), Error>;
50
51    /// GET /emergency-access/{id}
52    async fn get<'a>(
53        &self,
54        id: uuid::Uuid,
55    ) -> Result<models::EmergencyAccessGranteeDetailsResponseModel, Error>;
56
57    /// GET /emergency-access/{id}/{cipherId}/attachment/{attachmentId}
58    async fn get_attachment_data<'a>(
59        &self,
60        id: uuid::Uuid,
61        cipher_id: uuid::Uuid,
62        attachment_id: &'a str,
63    ) -> Result<models::AttachmentResponseModel, Error>;
64
65    /// GET /emergency-access/trusted
66    async fn get_contacts(
67        &self,
68    ) -> Result<models::EmergencyAccessGranteeDetailsResponseModelListResponseModel, Error>;
69
70    /// GET /emergency-access/granted
71    async fn get_grantees(
72        &self,
73    ) -> Result<models::EmergencyAccessGrantorDetailsResponseModelListResponseModel, Error>;
74
75    /// POST /emergency-access/{id}/initiate
76    async fn initiate<'a>(&self, id: uuid::Uuid) -> Result<(), Error>;
77
78    /// POST /emergency-access/invite
79    async fn invite<'a>(
80        &self,
81        emergency_access_invite_request_model: Option<models::EmergencyAccessInviteRequestModel>,
82    ) -> Result<(), Error>;
83
84    /// POST /emergency-access/{id}/password
85    async fn password<'a>(
86        &self,
87        id: uuid::Uuid,
88        emergency_access_password_request_model: Option<
89            models::EmergencyAccessPasswordRequestModel,
90        >,
91    ) -> Result<(), Error>;
92
93    /// GET /emergency-access/{id}/policies
94    async fn policies<'a>(
95        &self,
96        id: uuid::Uuid,
97    ) -> Result<models::PolicyResponseModelListResponseModel, Error>;
98
99    /// PUT /emergency-access/{id}
100    async fn put<'a>(
101        &self,
102        id: uuid::Uuid,
103        emergency_access_update_request_model: Option<models::EmergencyAccessUpdateRequestModel>,
104    ) -> Result<(), Error>;
105
106    /// POST /emergency-access/{id}/reinvite
107    async fn reinvite<'a>(&self, id: uuid::Uuid) -> Result<(), Error>;
108
109    /// POST /emergency-access/{id}/reject
110    async fn reject<'a>(&self, id: uuid::Uuid) -> Result<(), Error>;
111
112    /// POST /emergency-access/{id}/takeover
113    async fn takeover<'a>(
114        &self,
115        id: uuid::Uuid,
116    ) -> Result<models::EmergencyAccessTakeoverResponseModel, Error>;
117
118    /// POST /emergency-access/{id}/view
119    async fn view_ciphers<'a>(
120        &self,
121        id: uuid::Uuid,
122    ) -> Result<models::EmergencyAccessViewResponseModel, Error>;
123}
124
125pub struct EmergencyAccessApiClient {
126    configuration: Arc<configuration::Configuration>,
127}
128
129impl EmergencyAccessApiClient {
130    pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
131        Self { configuration }
132    }
133}
134
135#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
136#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
137impl EmergencyAccessApi for EmergencyAccessApiClient {
138    async fn accept<'a>(
139        &self,
140        id: uuid::Uuid,
141        organization_user_accept_request_model: Option<models::OrganizationUserAcceptRequestModel>,
142    ) -> Result<(), Error> {
143        let local_var_configuration = &self.configuration;
144
145        let local_var_client = &local_var_configuration.client;
146
147        let local_var_uri_str = format!(
148            "{}/emergency-access/{id}/accept",
149            local_var_configuration.base_path,
150            id = id
151        );
152        let mut local_var_req_builder =
153            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
154
155        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
156        local_var_req_builder = local_var_req_builder.json(&organization_user_accept_request_model);
157
158        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
159    }
160
161    async fn approve<'a>(&self, id: uuid::Uuid) -> Result<(), Error> {
162        let local_var_configuration = &self.configuration;
163
164        let local_var_client = &local_var_configuration.client;
165
166        let local_var_uri_str = format!(
167            "{}/emergency-access/{id}/approve",
168            local_var_configuration.base_path,
169            id = id
170        );
171        let mut local_var_req_builder =
172            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
173
174        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
175
176        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
177    }
178
179    async fn confirm<'a>(
180        &self,
181        id: uuid::Uuid,
182        organization_user_confirm_request_model: Option<
183            models::OrganizationUserConfirmRequestModel,
184        >,
185    ) -> Result<(), Error> {
186        let local_var_configuration = &self.configuration;
187
188        let local_var_client = &local_var_configuration.client;
189
190        let local_var_uri_str = format!(
191            "{}/emergency-access/{id}/confirm",
192            local_var_configuration.base_path,
193            id = id
194        );
195        let mut local_var_req_builder =
196            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
197
198        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
199        local_var_req_builder =
200            local_var_req_builder.json(&organization_user_confirm_request_model);
201
202        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
203    }
204
205    async fn delete<'a>(&self, id: uuid::Uuid) -> Result<(), Error> {
206        let local_var_configuration = &self.configuration;
207
208        let local_var_client = &local_var_configuration.client;
209
210        let local_var_uri_str = format!(
211            "{}/emergency-access/{id}",
212            local_var_configuration.base_path,
213            id = id
214        );
215        let mut local_var_req_builder =
216            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
217
218        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
219
220        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
221    }
222
223    async fn get<'a>(
224        &self,
225        id: uuid::Uuid,
226    ) -> Result<models::EmergencyAccessGranteeDetailsResponseModel, Error> {
227        let local_var_configuration = &self.configuration;
228
229        let local_var_client = &local_var_configuration.client;
230
231        let local_var_uri_str = format!(
232            "{}/emergency-access/{id}",
233            local_var_configuration.base_path,
234            id = id
235        );
236        let mut local_var_req_builder =
237            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
238
239        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
240
241        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
242    }
243
244    async fn get_attachment_data<'a>(
245        &self,
246        id: uuid::Uuid,
247        cipher_id: uuid::Uuid,
248        attachment_id: &'a str,
249    ) -> Result<models::AttachmentResponseModel, Error> {
250        let local_var_configuration = &self.configuration;
251
252        let local_var_client = &local_var_configuration.client;
253
254        let local_var_uri_str = format!(
255            "{}/emergency-access/{id}/{cipherId}/attachment/{attachmentId}",
256            local_var_configuration.base_path,
257            id = id,
258            cipherId = cipher_id,
259            attachmentId = crate::apis::urlencode(attachment_id)
260        );
261        let mut local_var_req_builder =
262            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
263
264        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
265
266        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
267    }
268
269    async fn get_contacts(
270        &self,
271    ) -> Result<models::EmergencyAccessGranteeDetailsResponseModelListResponseModel, Error> {
272        let local_var_configuration = &self.configuration;
273
274        let local_var_client = &local_var_configuration.client;
275
276        let local_var_uri_str = format!(
277            "{}/emergency-access/trusted",
278            local_var_configuration.base_path
279        );
280        let mut local_var_req_builder =
281            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
282
283        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
284
285        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
286    }
287
288    async fn get_grantees(
289        &self,
290    ) -> Result<models::EmergencyAccessGrantorDetailsResponseModelListResponseModel, Error> {
291        let local_var_configuration = &self.configuration;
292
293        let local_var_client = &local_var_configuration.client;
294
295        let local_var_uri_str = format!(
296            "{}/emergency-access/granted",
297            local_var_configuration.base_path
298        );
299        let mut local_var_req_builder =
300            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
301
302        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
303
304        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
305    }
306
307    async fn initiate<'a>(&self, id: uuid::Uuid) -> Result<(), Error> {
308        let local_var_configuration = &self.configuration;
309
310        let local_var_client = &local_var_configuration.client;
311
312        let local_var_uri_str = format!(
313            "{}/emergency-access/{id}/initiate",
314            local_var_configuration.base_path,
315            id = id
316        );
317        let mut local_var_req_builder =
318            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
319
320        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
321
322        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
323    }
324
325    async fn invite<'a>(
326        &self,
327        emergency_access_invite_request_model: Option<models::EmergencyAccessInviteRequestModel>,
328    ) -> Result<(), Error> {
329        let local_var_configuration = &self.configuration;
330
331        let local_var_client = &local_var_configuration.client;
332
333        let local_var_uri_str = format!(
334            "{}/emergency-access/invite",
335            local_var_configuration.base_path
336        );
337        let mut local_var_req_builder =
338            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
339
340        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
341        local_var_req_builder = local_var_req_builder.json(&emergency_access_invite_request_model);
342
343        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
344    }
345
346    async fn password<'a>(
347        &self,
348        id: uuid::Uuid,
349        emergency_access_password_request_model: Option<
350            models::EmergencyAccessPasswordRequestModel,
351        >,
352    ) -> Result<(), Error> {
353        let local_var_configuration = &self.configuration;
354
355        let local_var_client = &local_var_configuration.client;
356
357        let local_var_uri_str = format!(
358            "{}/emergency-access/{id}/password",
359            local_var_configuration.base_path,
360            id = id
361        );
362        let mut local_var_req_builder =
363            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
364
365        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
366        local_var_req_builder =
367            local_var_req_builder.json(&emergency_access_password_request_model);
368
369        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
370    }
371
372    async fn policies<'a>(
373        &self,
374        id: uuid::Uuid,
375    ) -> Result<models::PolicyResponseModelListResponseModel, Error> {
376        let local_var_configuration = &self.configuration;
377
378        let local_var_client = &local_var_configuration.client;
379
380        let local_var_uri_str = format!(
381            "{}/emergency-access/{id}/policies",
382            local_var_configuration.base_path,
383            id = id
384        );
385        let mut local_var_req_builder =
386            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
387
388        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
389
390        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
391    }
392
393    async fn put<'a>(
394        &self,
395        id: uuid::Uuid,
396        emergency_access_update_request_model: Option<models::EmergencyAccessUpdateRequestModel>,
397    ) -> Result<(), Error> {
398        let local_var_configuration = &self.configuration;
399
400        let local_var_client = &local_var_configuration.client;
401
402        let local_var_uri_str = format!(
403            "{}/emergency-access/{id}",
404            local_var_configuration.base_path,
405            id = id
406        );
407        let mut local_var_req_builder =
408            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
409
410        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
411        local_var_req_builder = local_var_req_builder.json(&emergency_access_update_request_model);
412
413        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
414    }
415
416    async fn reinvite<'a>(&self, id: uuid::Uuid) -> Result<(), Error> {
417        let local_var_configuration = &self.configuration;
418
419        let local_var_client = &local_var_configuration.client;
420
421        let local_var_uri_str = format!(
422            "{}/emergency-access/{id}/reinvite",
423            local_var_configuration.base_path,
424            id = id
425        );
426        let mut local_var_req_builder =
427            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
428
429        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
430
431        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
432    }
433
434    async fn reject<'a>(&self, id: uuid::Uuid) -> Result<(), Error> {
435        let local_var_configuration = &self.configuration;
436
437        let local_var_client = &local_var_configuration.client;
438
439        let local_var_uri_str = format!(
440            "{}/emergency-access/{id}/reject",
441            local_var_configuration.base_path,
442            id = id
443        );
444        let mut local_var_req_builder =
445            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
446
447        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
448
449        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
450    }
451
452    async fn takeover<'a>(
453        &self,
454        id: uuid::Uuid,
455    ) -> Result<models::EmergencyAccessTakeoverResponseModel, Error> {
456        let local_var_configuration = &self.configuration;
457
458        let local_var_client = &local_var_configuration.client;
459
460        let local_var_uri_str = format!(
461            "{}/emergency-access/{id}/takeover",
462            local_var_configuration.base_path,
463            id = id
464        );
465        let mut local_var_req_builder =
466            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
467
468        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
469
470        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
471    }
472
473    async fn view_ciphers<'a>(
474        &self,
475        id: uuid::Uuid,
476    ) -> Result<models::EmergencyAccessViewResponseModel, Error> {
477        let local_var_configuration = &self.configuration;
478
479        let local_var_client = &local_var_configuration.client;
480
481        let local_var_uri_str = format!(
482            "{}/emergency-access/{id}/view",
483            local_var_configuration.base_path,
484            id = id
485        );
486        let mut local_var_req_builder =
487            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
488
489        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
490
491        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
492    }
493}