1use 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 OrganizationUsersApi: Send + Sync {
29 async fn accept<'a>(
31 &self,
32 org_id: uuid::Uuid,
33 organization_user_id: uuid::Uuid,
34 organization_user_accept_request_model: Option<models::OrganizationUserAcceptRequestModel>,
35 ) -> Result<(), Error>;
36
37 async fn accept_init<'a>(
39 &self,
40 org_id: uuid::Uuid,
41 organization_user_id: uuid::Uuid,
42 organization_user_accept_init_request_model: Option<
43 models::OrganizationUserAcceptInitRequestModel,
44 >,
45 ) -> Result<(), Error>;
46
47 async fn automatically_confirm_organization_user<'a>(
49 &self,
50 org_id: uuid::Uuid,
51 id: uuid::Uuid,
52 organization_user_confirm_request_model: Option<
53 models::OrganizationUserConfirmRequestModel,
54 >,
55 ) -> Result<(), Error>;
56
57 async fn bulk_confirm<'a>(
59 &self,
60 org_id: uuid::Uuid,
61 organization_user_bulk_confirm_request_model: Option<
62 models::OrganizationUserBulkConfirmRequestModel,
63 >,
64 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
65
66 async fn bulk_delete_account<'a>(
68 &self,
69 org_id: uuid::Uuid,
70 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
71 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
72
73 async fn bulk_enable_secrets_manager<'a>(
75 &self,
76 org_id: uuid::Uuid,
77 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
78 ) -> Result<(), Error>;
79
80 async fn bulk_reinvite<'a>(
82 &self,
83 org_id: uuid::Uuid,
84 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
85 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
86
87 async fn bulk_remove<'a>(
89 &self,
90 org_id: uuid::Uuid,
91 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
92 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
93
94 async fn bulk_restore<'a>(
96 &self,
97 org_id: uuid::Uuid,
98 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
99 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
100
101 async fn bulk_revoke<'a>(
103 &self,
104 org_id: uuid::Uuid,
105 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
106 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
107
108 async fn confirm<'a>(
110 &self,
111 org_id: uuid::Uuid,
112 id: uuid::Uuid,
113 organization_user_confirm_request_model: Option<
114 models::OrganizationUserConfirmRequestModel,
115 >,
116 ) -> Result<(), Error>;
117
118 async fn delete_account<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error>;
120
121 async fn get<'a>(
123 &self,
124 org_id: uuid::Uuid,
125 id: uuid::Uuid,
126 include_groups: Option<bool>,
127 ) -> Result<models::OrganizationUserDetailsResponseModel, Error>;
128
129 async fn get_account_recovery_details<'a>(
131 &self,
132 org_id: uuid::Uuid,
133 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
134 ) -> Result<models::OrganizationUserResetPasswordDetailsResponseModelListResponseModel, Error>;
135
136 async fn get_all<'a>(
138 &self,
139 org_id: uuid::Uuid,
140 include_groups: Option<bool>,
141 include_collections: Option<bool>,
142 ) -> Result<models::OrganizationUserUserDetailsResponseModelListResponseModel, Error>;
143
144 async fn get_mini_details<'a>(
146 &self,
147 org_id: uuid::Uuid,
148 ) -> Result<models::OrganizationUserUserMiniDetailsResponseModelListResponseModel, Error>;
149
150 async fn get_reset_password_details<'a>(
152 &self,
153 org_id: uuid::Uuid,
154 id: uuid::Uuid,
155 ) -> Result<models::OrganizationUserResetPasswordDetailsResponseModel, Error>;
156
157 async fn invite<'a>(
159 &self,
160 org_id: uuid::Uuid,
161 organization_user_invite_request_model: Option<models::OrganizationUserInviteRequestModel>,
162 ) -> Result<(), Error>;
163
164 async fn put<'a>(
166 &self,
167 org_id: uuid::Uuid,
168 id: uuid::Uuid,
169 organization_user_update_request_model: Option<models::OrganizationUserUpdateRequestModel>,
170 ) -> Result<(), Error>;
171
172 async fn put_recover_account<'a>(
174 &self,
175 org_id: uuid::Uuid,
176 id: uuid::Uuid,
177 target_organization_user: Option<models::OrganizationUser>,
178 organization_user_reset_password_request_model: Option<
179 models::OrganizationUserResetPasswordRequestModel,
180 >,
181 ) -> Result<(), Error>;
182
183 async fn put_reset_password<'a>(
185 &self,
186 org_id: uuid::Uuid,
187 id: uuid::Uuid,
188 target_organization_user: Option<models::OrganizationUser>,
189 organization_user_reset_password_request_model: Option<
190 models::OrganizationUserResetPasswordRequestModel,
191 >,
192 ) -> Result<(), Error>;
193
194 async fn put_reset_password_enrollment<'a>(
196 &self,
197 org_id: uuid::Uuid,
198 user_id: uuid::Uuid,
199 organization_user_reset_password_enrollment_request_model: Option<
200 models::OrganizationUserResetPasswordEnrollmentRequestModel,
201 >,
202 ) -> Result<(), Error>;
203
204 async fn reinvite<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error>;
206
207 async fn remove<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error>;
209
210 async fn restore_async_v_next<'a>(
212 &self,
213 org_id: uuid::Uuid,
214 id: uuid::Uuid,
215 organization_user_restore_request: Option<models::OrganizationUserRestoreRequest>,
216 ) -> Result<(), Error>;
217
218 async fn revoke<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error>;
220
221 async fn revoke_self<'a>(&self, org_id: uuid::Uuid) -> Result<(), Error>;
223
224 async fn user_public_keys<'a>(
226 &self,
227 org_id: uuid::Uuid,
228 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
229 ) -> Result<models::OrganizationUserPublicKeyResponseModelListResponseModel, Error>;
230}
231
232pub struct OrganizationUsersApiClient {
233 configuration: Arc<configuration::Configuration>,
234}
235
236impl OrganizationUsersApiClient {
237 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
238 Self { configuration }
239 }
240}
241
242#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
243#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
244impl OrganizationUsersApi for OrganizationUsersApiClient {
245 async fn accept<'a>(
246 &self,
247 org_id: uuid::Uuid,
248 organization_user_id: uuid::Uuid,
249 organization_user_accept_request_model: Option<models::OrganizationUserAcceptRequestModel>,
250 ) -> Result<(), Error> {
251 let local_var_configuration = &self.configuration;
252
253 let local_var_client = &local_var_configuration.client;
254
255 let local_var_uri_str = format!(
256 "{}/organizations/{orgId}/users/{organizationUserId}/accept",
257 local_var_configuration.base_path,
258 orgId = org_id,
259 organizationUserId = organization_user_id
260 );
261 let mut local_var_req_builder =
262 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
263
264 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
265 local_var_req_builder = local_var_req_builder.json(&organization_user_accept_request_model);
266
267 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
268 }
269
270 async fn accept_init<'a>(
271 &self,
272 org_id: uuid::Uuid,
273 organization_user_id: uuid::Uuid,
274 organization_user_accept_init_request_model: Option<
275 models::OrganizationUserAcceptInitRequestModel,
276 >,
277 ) -> Result<(), Error> {
278 let local_var_configuration = &self.configuration;
279
280 let local_var_client = &local_var_configuration.client;
281
282 let local_var_uri_str = format!(
283 "{}/organizations/{orgId}/users/{organizationUserId}/accept-init",
284 local_var_configuration.base_path,
285 orgId = org_id,
286 organizationUserId = organization_user_id
287 );
288 let mut local_var_req_builder =
289 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
290
291 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
292 local_var_req_builder =
293 local_var_req_builder.json(&organization_user_accept_init_request_model);
294
295 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
296 }
297
298 async fn automatically_confirm_organization_user<'a>(
299 &self,
300 org_id: uuid::Uuid,
301 id: uuid::Uuid,
302 organization_user_confirm_request_model: Option<
303 models::OrganizationUserConfirmRequestModel,
304 >,
305 ) -> Result<(), Error> {
306 let local_var_configuration = &self.configuration;
307
308 let local_var_client = &local_var_configuration.client;
309
310 let local_var_uri_str = format!(
311 "{}/organizations/{orgId}/users/{id}/auto-confirm",
312 local_var_configuration.base_path,
313 orgId = org_id,
314 id = id
315 );
316 let mut local_var_req_builder =
317 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
318
319 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
320 local_var_req_builder =
321 local_var_req_builder.json(&organization_user_confirm_request_model);
322
323 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
324 }
325
326 async fn bulk_confirm<'a>(
327 &self,
328 org_id: uuid::Uuid,
329 organization_user_bulk_confirm_request_model: Option<
330 models::OrganizationUserBulkConfirmRequestModel,
331 >,
332 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
333 let local_var_configuration = &self.configuration;
334
335 let local_var_client = &local_var_configuration.client;
336
337 let local_var_uri_str = format!(
338 "{}/organizations/{orgId}/users/confirm",
339 local_var_configuration.base_path,
340 orgId = org_id
341 );
342 let mut local_var_req_builder =
343 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
344
345 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
346 local_var_req_builder =
347 local_var_req_builder.json(&organization_user_bulk_confirm_request_model);
348
349 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
350 }
351
352 async fn bulk_delete_account<'a>(
353 &self,
354 org_id: uuid::Uuid,
355 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
356 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
357 let local_var_configuration = &self.configuration;
358
359 let local_var_client = &local_var_configuration.client;
360
361 let local_var_uri_str = format!(
362 "{}/organizations/{orgId}/users/delete-account",
363 local_var_configuration.base_path,
364 orgId = org_id
365 );
366 let mut local_var_req_builder =
367 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
368
369 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
370 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
371
372 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
373 }
374
375 async fn bulk_enable_secrets_manager<'a>(
376 &self,
377 org_id: uuid::Uuid,
378 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
379 ) -> Result<(), Error> {
380 let local_var_configuration = &self.configuration;
381
382 let local_var_client = &local_var_configuration.client;
383
384 let local_var_uri_str = format!(
385 "{}/organizations/{orgId}/users/enable-secrets-manager",
386 local_var_configuration.base_path,
387 orgId = org_id
388 );
389 let mut local_var_req_builder =
390 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
391
392 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
393 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
394
395 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
396 }
397
398 async fn bulk_reinvite<'a>(
399 &self,
400 org_id: uuid::Uuid,
401 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
402 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
403 let local_var_configuration = &self.configuration;
404
405 let local_var_client = &local_var_configuration.client;
406
407 let local_var_uri_str = format!(
408 "{}/organizations/{orgId}/users/reinvite",
409 local_var_configuration.base_path,
410 orgId = org_id
411 );
412 let mut local_var_req_builder =
413 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
414
415 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
416 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
417
418 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
419 }
420
421 async fn bulk_remove<'a>(
422 &self,
423 org_id: uuid::Uuid,
424 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
425 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
426 let local_var_configuration = &self.configuration;
427
428 let local_var_client = &local_var_configuration.client;
429
430 let local_var_uri_str = format!(
431 "{}/organizations/{orgId}/users",
432 local_var_configuration.base_path,
433 orgId = org_id
434 );
435 let mut local_var_req_builder =
436 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
437
438 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
439 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
440
441 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
442 }
443
444 async fn bulk_restore<'a>(
445 &self,
446 org_id: uuid::Uuid,
447 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
448 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
449 let local_var_configuration = &self.configuration;
450
451 let local_var_client = &local_var_configuration.client;
452
453 let local_var_uri_str = format!(
454 "{}/organizations/{orgId}/users/restore",
455 local_var_configuration.base_path,
456 orgId = org_id
457 );
458 let mut local_var_req_builder =
459 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
460
461 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
462 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
463
464 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
465 }
466
467 async fn bulk_revoke<'a>(
468 &self,
469 org_id: uuid::Uuid,
470 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
471 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
472 let local_var_configuration = &self.configuration;
473
474 let local_var_client = &local_var_configuration.client;
475
476 let local_var_uri_str = format!(
477 "{}/organizations/{orgId}/users/revoke",
478 local_var_configuration.base_path,
479 orgId = org_id
480 );
481 let mut local_var_req_builder =
482 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
483
484 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
485 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
486
487 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
488 }
489
490 async fn confirm<'a>(
491 &self,
492 org_id: uuid::Uuid,
493 id: uuid::Uuid,
494 organization_user_confirm_request_model: Option<
495 models::OrganizationUserConfirmRequestModel,
496 >,
497 ) -> Result<(), Error> {
498 let local_var_configuration = &self.configuration;
499
500 let local_var_client = &local_var_configuration.client;
501
502 let local_var_uri_str = format!(
503 "{}/organizations/{orgId}/users/{id}/confirm",
504 local_var_configuration.base_path,
505 orgId = org_id,
506 id = id
507 );
508 let mut local_var_req_builder =
509 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
510
511 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
512 local_var_req_builder =
513 local_var_req_builder.json(&organization_user_confirm_request_model);
514
515 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
516 }
517
518 async fn delete_account<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error> {
519 let local_var_configuration = &self.configuration;
520
521 let local_var_client = &local_var_configuration.client;
522
523 let local_var_uri_str = format!(
524 "{}/organizations/{orgId}/users/{id}/delete-account",
525 local_var_configuration.base_path,
526 orgId = org_id,
527 id = id
528 );
529 let mut local_var_req_builder =
530 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
531
532 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
533
534 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
535 }
536
537 async fn get<'a>(
538 &self,
539 org_id: uuid::Uuid,
540 id: uuid::Uuid,
541 include_groups: Option<bool>,
542 ) -> Result<models::OrganizationUserDetailsResponseModel, Error> {
543 let local_var_configuration = &self.configuration;
544
545 let local_var_client = &local_var_configuration.client;
546
547 let local_var_uri_str = format!(
548 "{}/organizations/{orgId}/users/{id}",
549 local_var_configuration.base_path,
550 orgId = org_id,
551 id = id
552 );
553 let mut local_var_req_builder =
554 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
555
556 if let Some(ref param_value) = include_groups {
557 local_var_req_builder =
558 local_var_req_builder.query(&[("includeGroups", ¶m_value.to_string())]);
559 }
560 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
561
562 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
563 }
564
565 async fn get_account_recovery_details<'a>(
566 &self,
567 org_id: uuid::Uuid,
568 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
569 ) -> Result<models::OrganizationUserResetPasswordDetailsResponseModelListResponseModel, Error>
570 {
571 let local_var_configuration = &self.configuration;
572
573 let local_var_client = &local_var_configuration.client;
574
575 let local_var_uri_str = format!(
576 "{}/organizations/{orgId}/users/account-recovery-details",
577 local_var_configuration.base_path,
578 orgId = org_id
579 );
580 let mut local_var_req_builder =
581 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
582
583 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
584 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
585
586 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
587 }
588
589 async fn get_all<'a>(
590 &self,
591 org_id: uuid::Uuid,
592 include_groups: Option<bool>,
593 include_collections: Option<bool>,
594 ) -> Result<models::OrganizationUserUserDetailsResponseModelListResponseModel, Error> {
595 let local_var_configuration = &self.configuration;
596
597 let local_var_client = &local_var_configuration.client;
598
599 let local_var_uri_str = format!(
600 "{}/organizations/{orgId}/users",
601 local_var_configuration.base_path,
602 orgId = org_id
603 );
604 let mut local_var_req_builder =
605 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
606
607 if let Some(ref param_value) = include_groups {
608 local_var_req_builder =
609 local_var_req_builder.query(&[("includeGroups", ¶m_value.to_string())]);
610 }
611 if let Some(ref param_value) = include_collections {
612 local_var_req_builder =
613 local_var_req_builder.query(&[("includeCollections", ¶m_value.to_string())]);
614 }
615 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
616
617 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
618 }
619
620 async fn get_mini_details<'a>(
621 &self,
622 org_id: uuid::Uuid,
623 ) -> Result<models::OrganizationUserUserMiniDetailsResponseModelListResponseModel, Error> {
624 let local_var_configuration = &self.configuration;
625
626 let local_var_client = &local_var_configuration.client;
627
628 let local_var_uri_str = format!(
629 "{}/organizations/{orgId}/users/mini-details",
630 local_var_configuration.base_path,
631 orgId = org_id
632 );
633 let mut local_var_req_builder =
634 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
635
636 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
637
638 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
639 }
640
641 async fn get_reset_password_details<'a>(
642 &self,
643 org_id: uuid::Uuid,
644 id: uuid::Uuid,
645 ) -> Result<models::OrganizationUserResetPasswordDetailsResponseModel, Error> {
646 let local_var_configuration = &self.configuration;
647
648 let local_var_client = &local_var_configuration.client;
649
650 let local_var_uri_str = format!(
651 "{}/organizations/{orgId}/users/{id}/reset-password-details",
652 local_var_configuration.base_path,
653 orgId = org_id,
654 id = id
655 );
656 let mut local_var_req_builder =
657 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
658
659 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
660
661 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
662 }
663
664 async fn invite<'a>(
665 &self,
666 org_id: uuid::Uuid,
667 organization_user_invite_request_model: Option<models::OrganizationUserInviteRequestModel>,
668 ) -> Result<(), Error> {
669 let local_var_configuration = &self.configuration;
670
671 let local_var_client = &local_var_configuration.client;
672
673 let local_var_uri_str = format!(
674 "{}/organizations/{orgId}/users/invite",
675 local_var_configuration.base_path,
676 orgId = org_id
677 );
678 let mut local_var_req_builder =
679 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
680
681 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
682 local_var_req_builder = local_var_req_builder.json(&organization_user_invite_request_model);
683
684 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
685 }
686
687 async fn put<'a>(
688 &self,
689 org_id: uuid::Uuid,
690 id: uuid::Uuid,
691 organization_user_update_request_model: Option<models::OrganizationUserUpdateRequestModel>,
692 ) -> Result<(), Error> {
693 let local_var_configuration = &self.configuration;
694
695 let local_var_client = &local_var_configuration.client;
696
697 let local_var_uri_str = format!(
698 "{}/organizations/{orgId}/users/{id}",
699 local_var_configuration.base_path,
700 orgId = org_id,
701 id = id
702 );
703 let mut local_var_req_builder =
704 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
705
706 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
707 local_var_req_builder = local_var_req_builder.json(&organization_user_update_request_model);
708
709 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
710 }
711
712 async fn put_recover_account<'a>(
713 &self,
714 org_id: uuid::Uuid,
715 id: uuid::Uuid,
716 target_organization_user: Option<models::OrganizationUser>,
717 organization_user_reset_password_request_model: Option<
718 models::OrganizationUserResetPasswordRequestModel,
719 >,
720 ) -> Result<(), Error> {
721 let local_var_configuration = &self.configuration;
722
723 let local_var_client = &local_var_configuration.client;
724
725 let local_var_uri_str = format!(
726 "{}/organizations/{orgId}/users/{id}/recover-account",
727 local_var_configuration.base_path,
728 orgId = org_id,
729 id = id
730 );
731 let mut local_var_req_builder =
732 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
733
734 if let Some(ref param_value) = target_organization_user {
735 local_var_req_builder = local_var_req_builder.query(&[(
736 "targetOrganizationUser",
737 &serde_json::to_value(param_value)?,
738 )]);
739 }
740 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
741 local_var_req_builder =
742 local_var_req_builder.json(&organization_user_reset_password_request_model);
743
744 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
745 }
746
747 async fn put_reset_password<'a>(
748 &self,
749 org_id: uuid::Uuid,
750 id: uuid::Uuid,
751 target_organization_user: Option<models::OrganizationUser>,
752 organization_user_reset_password_request_model: Option<
753 models::OrganizationUserResetPasswordRequestModel,
754 >,
755 ) -> Result<(), Error> {
756 let local_var_configuration = &self.configuration;
757
758 let local_var_client = &local_var_configuration.client;
759
760 let local_var_uri_str = format!(
761 "{}/organizations/{orgId}/users/{id}/reset-password",
762 local_var_configuration.base_path,
763 orgId = org_id,
764 id = id
765 );
766 let mut local_var_req_builder =
767 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
768
769 if let Some(ref param_value) = target_organization_user {
770 local_var_req_builder = local_var_req_builder.query(&[(
771 "targetOrganizationUser",
772 &serde_json::to_value(param_value)?,
773 )]);
774 }
775 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
776 local_var_req_builder =
777 local_var_req_builder.json(&organization_user_reset_password_request_model);
778
779 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
780 }
781
782 async fn put_reset_password_enrollment<'a>(
783 &self,
784 org_id: uuid::Uuid,
785 user_id: uuid::Uuid,
786 organization_user_reset_password_enrollment_request_model: Option<
787 models::OrganizationUserResetPasswordEnrollmentRequestModel,
788 >,
789 ) -> Result<(), Error> {
790 let local_var_configuration = &self.configuration;
791
792 let local_var_client = &local_var_configuration.client;
793
794 let local_var_uri_str = format!(
795 "{}/organizations/{orgId}/users/{userId}/reset-password-enrollment",
796 local_var_configuration.base_path,
797 orgId = org_id,
798 userId = user_id
799 );
800 let mut local_var_req_builder =
801 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
802
803 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
804 local_var_req_builder =
805 local_var_req_builder.json(&organization_user_reset_password_enrollment_request_model);
806
807 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
808 }
809
810 async fn reinvite<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error> {
811 let local_var_configuration = &self.configuration;
812
813 let local_var_client = &local_var_configuration.client;
814
815 let local_var_uri_str = format!(
816 "{}/organizations/{orgId}/users/{id}/reinvite",
817 local_var_configuration.base_path,
818 orgId = org_id,
819 id = id
820 );
821 let mut local_var_req_builder =
822 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
823
824 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
825
826 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
827 }
828
829 async fn remove<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error> {
830 let local_var_configuration = &self.configuration;
831
832 let local_var_client = &local_var_configuration.client;
833
834 let local_var_uri_str = format!(
835 "{}/organizations/{orgId}/users/{id}",
836 local_var_configuration.base_path,
837 orgId = org_id,
838 id = id
839 );
840 let mut local_var_req_builder =
841 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
842
843 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
844
845 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
846 }
847
848 async fn restore_async_v_next<'a>(
849 &self,
850 org_id: uuid::Uuid,
851 id: uuid::Uuid,
852 organization_user_restore_request: Option<models::OrganizationUserRestoreRequest>,
853 ) -> Result<(), Error> {
854 let local_var_configuration = &self.configuration;
855
856 let local_var_client = &local_var_configuration.client;
857
858 let local_var_uri_str = format!(
859 "{}/organizations/{orgId}/users/{id}/restore/vnext",
860 local_var_configuration.base_path,
861 orgId = org_id,
862 id = id
863 );
864 let mut local_var_req_builder =
865 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
866
867 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
868 local_var_req_builder = local_var_req_builder.json(&organization_user_restore_request);
869
870 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
871 }
872
873 async fn revoke<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error> {
874 let local_var_configuration = &self.configuration;
875
876 let local_var_client = &local_var_configuration.client;
877
878 let local_var_uri_str = format!(
879 "{}/organizations/{orgId}/users/{id}/revoke",
880 local_var_configuration.base_path,
881 orgId = org_id,
882 id = id
883 );
884 let mut local_var_req_builder =
885 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
886
887 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
888
889 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
890 }
891
892 async fn revoke_self<'a>(&self, org_id: uuid::Uuid) -> Result<(), Error> {
893 let local_var_configuration = &self.configuration;
894
895 let local_var_client = &local_var_configuration.client;
896
897 let local_var_uri_str = format!(
898 "{}/organizations/{orgId}/users/revoke-self",
899 local_var_configuration.base_path,
900 orgId = org_id
901 );
902 let mut local_var_req_builder =
903 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
904
905 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
906
907 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
908 }
909
910 async fn user_public_keys<'a>(
911 &self,
912 org_id: uuid::Uuid,
913 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
914 ) -> Result<models::OrganizationUserPublicKeyResponseModelListResponseModel, Error> {
915 let local_var_configuration = &self.configuration;
916
917 let local_var_client = &local_var_configuration.client;
918
919 let local_var_uri_str = format!(
920 "{}/organizations/{orgId}/users/public-keys",
921 local_var_configuration.base_path,
922 orgId = org_id
923 );
924 let mut local_var_req_builder =
925 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
926
927 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
928 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
929
930 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
931 }
932}