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 accept_invite_link<'a>(
49 &self,
50 accept_organization_invite_link_request_model: Option<
51 models::AcceptOrganizationInviteLinkRequestModel,
52 >,
53 ) -> Result<(), Error>;
54
55 async fn automatically_confirm_organization_user<'a>(
57 &self,
58 id: uuid::Uuid,
59 org_id: &'a str,
60 organization: Option<models::Organization>,
61 organization_user_confirm_request_model: Option<
62 models::OrganizationUserConfirmRequestModel,
63 >,
64 ) -> Result<(), Error>;
65
66 async fn bulk_automatically_confirm_organization_users<'a>(
68 &self,
69 org_id: &'a str,
70 organization: Option<models::Organization>,
71 organization_user_bulk_confirm_request_model: Option<
72 models::OrganizationUserBulkConfirmRequestModel,
73 >,
74 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
75
76 async fn bulk_confirm<'a>(
78 &self,
79 org_id: uuid::Uuid,
80 organization_user_bulk_confirm_request_model: Option<
81 models::OrganizationUserBulkConfirmRequestModel,
82 >,
83 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
84
85 async fn bulk_delete_account<'a>(
87 &self,
88 org_id: uuid::Uuid,
89 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
90 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
91
92 async fn bulk_enable_pam<'a>(
94 &self,
95 org_id: &'a str,
96 organization: Option<models::Organization>,
97 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
98 ) -> Result<(), Error>;
99
100 async fn bulk_enable_secrets_manager<'a>(
102 &self,
103 org_id: uuid::Uuid,
104 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
105 ) -> Result<(), Error>;
106
107 async fn bulk_reinvite<'a>(
109 &self,
110 org_id: uuid::Uuid,
111 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
112 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
113
114 async fn bulk_remove<'a>(
116 &self,
117 org_id: uuid::Uuid,
118 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
119 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
120
121 async fn bulk_restore<'a>(
123 &self,
124 org_id: uuid::Uuid,
125 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
126 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
127
128 async fn bulk_revoke<'a>(
130 &self,
131 org_id: uuid::Uuid,
132 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
133 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
134
135 async fn confirm<'a>(
137 &self,
138 org_id: uuid::Uuid,
139 id: uuid::Uuid,
140 organization_user_confirm_request_model: Option<
141 models::OrganizationUserConfirmRequestModel,
142 >,
143 ) -> Result<(), Error>;
144
145 async fn confirm_invite_link<'a>(
147 &self,
148 confirm_organization_invite_link_request_model: Option<
149 models::ConfirmOrganizationInviteLinkRequestModel,
150 >,
151 ) -> Result<(), Error>;
152
153 async fn delete_account<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error>;
155
156 async fn get<'a>(
158 &self,
159 org_id: uuid::Uuid,
160 id: uuid::Uuid,
161 include_groups: Option<bool>,
162 ) -> Result<models::OrganizationUserDetailsResponseModel, Error>;
163
164 async fn get_account_recovery_details<'a>(
166 &self,
167 org_id: uuid::Uuid,
168 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
169 ) -> Result<models::OrganizationUserResetPasswordDetailsResponseModelListResponseModel, Error>;
170
171 async fn get_all<'a>(
173 &self,
174 org_id: uuid::Uuid,
175 include_groups: Option<bool>,
176 include_collections: Option<bool>,
177 ) -> Result<models::OrganizationUserUserDetailsResponseModelListResponseModel, Error>;
178
179 async fn get_invite<'a>(
181 &self,
182 get_organization_invite_request_model: Option<models::GetOrganizationInviteRequestModel>,
183 ) -> Result<models::OrganizationInviteResponseModel, Error>;
184
185 async fn get_mini_details<'a>(
187 &self,
188 org_id: uuid::Uuid,
189 ) -> Result<models::OrganizationUserUserMiniDetailsResponseModelListResponseModel, Error>;
190
191 async fn get_pending_auto_confirm_users<'a>(
193 &self,
194 org_id: uuid::Uuid,
195 ) -> Result<models::OrganizationUserPendingAutoConfirmResponseModelListResponseModel, Error>;
196
197 async fn get_reset_password_details<'a>(
199 &self,
200 id: uuid::Uuid,
201 org_id: &'a str,
202 organization: Option<models::Organization>,
203 ) -> Result<models::OrganizationUserResetPasswordDetailsResponseModel, Error>;
204
205 async fn invite<'a>(
207 &self,
208 org_id: uuid::Uuid,
209 organization_user_invite_request_model: Option<models::OrganizationUserInviteRequestModel>,
210 ) -> Result<(), Error>;
211
212 async fn put<'a>(
214 &self,
215 id: uuid::Uuid,
216 org_id: &'a str,
217 organization: Option<models::Organization>,
218 organization_user_update_request_model: Option<models::OrganizationUserUpdateRequestModel>,
219 ) -> Result<(), Error>;
220
221 async fn put_reset_password_enrollment<'a>(
223 &self,
224 org_id: uuid::Uuid,
225 user_id: uuid::Uuid,
226 organization_user_reset_password_enrollment_request_model: Option<
227 models::OrganizationUserResetPasswordEnrollmentRequestModel,
228 >,
229 ) -> Result<(), Error>;
230
231 async fn recover_account<'a>(
233 &self,
234 org_id: uuid::Uuid,
235 id: uuid::Uuid,
236 target_organization_user: Option<models::OrganizationUser>,
237 organization_user_reset_password_request_model: Option<
238 models::OrganizationUserResetPasswordRequestModel,
239 >,
240 ) -> Result<(), Error>;
241
242 async fn reinvite<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error>;
244
245 async fn remove<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error>;
247
248 async fn restore_async_v_next<'a>(
250 &self,
251 org_id: uuid::Uuid,
252 id: uuid::Uuid,
253 organization_user_restore_request: Option<models::OrganizationUserRestoreRequest>,
254 ) -> Result<(), Error>;
255
256 async fn revoke<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error>;
258
259 async fn revoke_self<'a>(&self, org_id: uuid::Uuid) -> Result<(), Error>;
261
262 async fn send_invite_to_staged_users<'a>(
265 &self,
266 org_id: uuid::Uuid,
267 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
268 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
269
270 async fn user_public_keys<'a>(
272 &self,
273 org_id: uuid::Uuid,
274 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
275 ) -> Result<models::OrganizationUserPublicKeyResponseModelListResponseModel, Error>;
276}
277
278pub struct OrganizationUsersApiClient {
279 configuration: Arc<configuration::Configuration>,
280}
281
282impl OrganizationUsersApiClient {
283 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
284 Self { configuration }
285 }
286}
287
288#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
289#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
290impl OrganizationUsersApi for OrganizationUsersApiClient {
291 async fn accept<'a>(
292 &self,
293 org_id: uuid::Uuid,
294 organization_user_id: uuid::Uuid,
295 organization_user_accept_request_model: Option<models::OrganizationUserAcceptRequestModel>,
296 ) -> Result<(), Error> {
297 let local_var_configuration = &self.configuration;
298
299 let local_var_client = &local_var_configuration.client;
300
301 let local_var_uri_str = format!(
302 "{}/organizations/{orgId}/users/{organizationUserId}/accept",
303 local_var_configuration.base_path,
304 orgId = org_id,
305 organizationUserId = organization_user_id
306 );
307 let mut local_var_req_builder =
308 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
309
310 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
311 local_var_req_builder = local_var_req_builder.json(&organization_user_accept_request_model);
312
313 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
314 }
315
316 async fn accept_init<'a>(
317 &self,
318 org_id: uuid::Uuid,
319 organization_user_id: uuid::Uuid,
320 organization_user_accept_init_request_model: Option<
321 models::OrganizationUserAcceptInitRequestModel,
322 >,
323 ) -> Result<(), Error> {
324 let local_var_configuration = &self.configuration;
325
326 let local_var_client = &local_var_configuration.client;
327
328 let local_var_uri_str = format!(
329 "{}/organizations/{orgId}/users/{organizationUserId}/accept-init",
330 local_var_configuration.base_path,
331 orgId = org_id,
332 organizationUserId = organization_user_id
333 );
334 let mut local_var_req_builder =
335 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
336
337 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
338 local_var_req_builder =
339 local_var_req_builder.json(&organization_user_accept_init_request_model);
340
341 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
342 }
343
344 async fn accept_invite_link<'a>(
345 &self,
346 accept_organization_invite_link_request_model: Option<
347 models::AcceptOrganizationInviteLinkRequestModel,
348 >,
349 ) -> Result<(), Error> {
350 let local_var_configuration = &self.configuration;
351
352 let local_var_client = &local_var_configuration.client;
353
354 let local_var_uri_str = format!(
355 "{}/organizations/users/invite-link/accept",
356 local_var_configuration.base_path
357 );
358 let mut local_var_req_builder =
359 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
360
361 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
362 local_var_req_builder =
363 local_var_req_builder.json(&accept_organization_invite_link_request_model);
364
365 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
366 }
367
368 async fn automatically_confirm_organization_user<'a>(
369 &self,
370 id: uuid::Uuid,
371 org_id: &'a str,
372 organization: Option<models::Organization>,
373 organization_user_confirm_request_model: Option<
374 models::OrganizationUserConfirmRequestModel,
375 >,
376 ) -> Result<(), Error> {
377 let local_var_configuration = &self.configuration;
378
379 let local_var_client = &local_var_configuration.client;
380
381 let local_var_uri_str = format!(
382 "{}/organizations/{orgId}/users/{id}/auto-confirm",
383 local_var_configuration.base_path,
384 id = id,
385 orgId = crate::apis::urlencode(org_id)
386 );
387 let mut local_var_req_builder =
388 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
389
390 if let Some(ref param_value) = organization {
391 local_var_req_builder = local_var_req_builder
392 .query(&[("organization", &serde_json::to_value(param_value)?)]);
393 }
394 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
395 local_var_req_builder =
396 local_var_req_builder.json(&organization_user_confirm_request_model);
397
398 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
399 }
400
401 async fn bulk_automatically_confirm_organization_users<'a>(
402 &self,
403 org_id: &'a str,
404 organization: Option<models::Organization>,
405 organization_user_bulk_confirm_request_model: Option<
406 models::OrganizationUserBulkConfirmRequestModel,
407 >,
408 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
409 let local_var_configuration = &self.configuration;
410
411 let local_var_client = &local_var_configuration.client;
412
413 let local_var_uri_str = format!(
414 "{}/organizations/{orgId}/users/bulk-auto-confirm",
415 local_var_configuration.base_path,
416 orgId = crate::apis::urlencode(org_id)
417 );
418 let mut local_var_req_builder =
419 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
420
421 if let Some(ref param_value) = organization {
422 local_var_req_builder = local_var_req_builder
423 .query(&[("organization", &serde_json::to_value(param_value)?)]);
424 }
425 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
426 local_var_req_builder =
427 local_var_req_builder.json(&organization_user_bulk_confirm_request_model);
428
429 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
430 }
431
432 async fn bulk_confirm<'a>(
433 &self,
434 org_id: uuid::Uuid,
435 organization_user_bulk_confirm_request_model: Option<
436 models::OrganizationUserBulkConfirmRequestModel,
437 >,
438 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
439 let local_var_configuration = &self.configuration;
440
441 let local_var_client = &local_var_configuration.client;
442
443 let local_var_uri_str = format!(
444 "{}/organizations/{orgId}/users/confirm",
445 local_var_configuration.base_path,
446 orgId = org_id
447 );
448 let mut local_var_req_builder =
449 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
450
451 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
452 local_var_req_builder =
453 local_var_req_builder.json(&organization_user_bulk_confirm_request_model);
454
455 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
456 }
457
458 async fn bulk_delete_account<'a>(
459 &self,
460 org_id: uuid::Uuid,
461 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
462 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
463 let local_var_configuration = &self.configuration;
464
465 let local_var_client = &local_var_configuration.client;
466
467 let local_var_uri_str = format!(
468 "{}/organizations/{orgId}/users/delete-account",
469 local_var_configuration.base_path,
470 orgId = org_id
471 );
472 let mut local_var_req_builder =
473 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
474
475 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
476 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
477
478 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
479 }
480
481 async fn bulk_enable_pam<'a>(
482 &self,
483 org_id: &'a str,
484 organization: Option<models::Organization>,
485 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
486 ) -> Result<(), Error> {
487 let local_var_configuration = &self.configuration;
488
489 let local_var_client = &local_var_configuration.client;
490
491 let local_var_uri_str = format!(
492 "{}/organizations/{orgId}/users/enable-pam",
493 local_var_configuration.base_path,
494 orgId = crate::apis::urlencode(org_id)
495 );
496 let mut local_var_req_builder =
497 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
498
499 if let Some(ref param_value) = organization {
500 local_var_req_builder = local_var_req_builder
501 .query(&[("organization", &serde_json::to_value(param_value)?)]);
502 }
503 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
504 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
505
506 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
507 }
508
509 async fn bulk_enable_secrets_manager<'a>(
510 &self,
511 org_id: uuid::Uuid,
512 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
513 ) -> Result<(), Error> {
514 let local_var_configuration = &self.configuration;
515
516 let local_var_client = &local_var_configuration.client;
517
518 let local_var_uri_str = format!(
519 "{}/organizations/{orgId}/users/enable-secrets-manager",
520 local_var_configuration.base_path,
521 orgId = org_id
522 );
523 let mut local_var_req_builder =
524 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
525
526 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
527 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
528
529 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
530 }
531
532 async fn bulk_reinvite<'a>(
533 &self,
534 org_id: uuid::Uuid,
535 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
536 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
537 let local_var_configuration = &self.configuration;
538
539 let local_var_client = &local_var_configuration.client;
540
541 let local_var_uri_str = format!(
542 "{}/organizations/{orgId}/users/reinvite",
543 local_var_configuration.base_path,
544 orgId = org_id
545 );
546 let mut local_var_req_builder =
547 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
548
549 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
550 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
551
552 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
553 }
554
555 async fn bulk_remove<'a>(
556 &self,
557 org_id: uuid::Uuid,
558 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
559 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
560 let local_var_configuration = &self.configuration;
561
562 let local_var_client = &local_var_configuration.client;
563
564 let local_var_uri_str = format!(
565 "{}/organizations/{orgId}/users",
566 local_var_configuration.base_path,
567 orgId = org_id
568 );
569 let mut local_var_req_builder =
570 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
571
572 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
573 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
574
575 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
576 }
577
578 async fn bulk_restore<'a>(
579 &self,
580 org_id: uuid::Uuid,
581 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
582 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
583 let local_var_configuration = &self.configuration;
584
585 let local_var_client = &local_var_configuration.client;
586
587 let local_var_uri_str = format!(
588 "{}/organizations/{orgId}/users/restore",
589 local_var_configuration.base_path,
590 orgId = org_id
591 );
592 let mut local_var_req_builder =
593 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
594
595 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
596 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
597
598 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
599 }
600
601 async fn bulk_revoke<'a>(
602 &self,
603 org_id: uuid::Uuid,
604 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
605 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
606 let local_var_configuration = &self.configuration;
607
608 let local_var_client = &local_var_configuration.client;
609
610 let local_var_uri_str = format!(
611 "{}/organizations/{orgId}/users/revoke",
612 local_var_configuration.base_path,
613 orgId = org_id
614 );
615 let mut local_var_req_builder =
616 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
617
618 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
619 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
620
621 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
622 }
623
624 async fn confirm<'a>(
625 &self,
626 org_id: uuid::Uuid,
627 id: uuid::Uuid,
628 organization_user_confirm_request_model: Option<
629 models::OrganizationUserConfirmRequestModel,
630 >,
631 ) -> Result<(), Error> {
632 let local_var_configuration = &self.configuration;
633
634 let local_var_client = &local_var_configuration.client;
635
636 let local_var_uri_str = format!(
637 "{}/organizations/{orgId}/users/{id}/confirm",
638 local_var_configuration.base_path,
639 orgId = org_id,
640 id = id
641 );
642 let mut local_var_req_builder =
643 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
644
645 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
646 local_var_req_builder =
647 local_var_req_builder.json(&organization_user_confirm_request_model);
648
649 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
650 }
651
652 async fn confirm_invite_link<'a>(
653 &self,
654 confirm_organization_invite_link_request_model: Option<
655 models::ConfirmOrganizationInviteLinkRequestModel,
656 >,
657 ) -> Result<(), Error> {
658 let local_var_configuration = &self.configuration;
659
660 let local_var_client = &local_var_configuration.client;
661
662 let local_var_uri_str = format!(
663 "{}/organizations/users/invite-link/confirm",
664 local_var_configuration.base_path
665 );
666 let mut local_var_req_builder =
667 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
668
669 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
670 local_var_req_builder =
671 local_var_req_builder.json(&confirm_organization_invite_link_request_model);
672
673 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
674 }
675
676 async fn delete_account<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error> {
677 let local_var_configuration = &self.configuration;
678
679 let local_var_client = &local_var_configuration.client;
680
681 let local_var_uri_str = format!(
682 "{}/organizations/{orgId}/users/{id}/delete-account",
683 local_var_configuration.base_path,
684 orgId = org_id,
685 id = id
686 );
687 let mut local_var_req_builder =
688 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
689
690 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
691
692 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
693 }
694
695 async fn get<'a>(
696 &self,
697 org_id: uuid::Uuid,
698 id: uuid::Uuid,
699 include_groups: Option<bool>,
700 ) -> Result<models::OrganizationUserDetailsResponseModel, Error> {
701 let local_var_configuration = &self.configuration;
702
703 let local_var_client = &local_var_configuration.client;
704
705 let local_var_uri_str = format!(
706 "{}/organizations/{orgId}/users/{id}",
707 local_var_configuration.base_path,
708 orgId = org_id,
709 id = id
710 );
711 let mut local_var_req_builder =
712 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
713
714 if let Some(ref param_value) = include_groups {
715 local_var_req_builder =
716 local_var_req_builder.query(&[("includeGroups", ¶m_value.to_string())]);
717 }
718 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
719
720 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
721 }
722
723 async fn get_account_recovery_details<'a>(
724 &self,
725 org_id: uuid::Uuid,
726 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
727 ) -> Result<models::OrganizationUserResetPasswordDetailsResponseModelListResponseModel, Error>
728 {
729 let local_var_configuration = &self.configuration;
730
731 let local_var_client = &local_var_configuration.client;
732
733 let local_var_uri_str = format!(
734 "{}/organizations/{orgId}/users/account-recovery-details",
735 local_var_configuration.base_path,
736 orgId = org_id
737 );
738 let mut local_var_req_builder =
739 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
740
741 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
742 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
743
744 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
745 }
746
747 async fn get_all<'a>(
748 &self,
749 org_id: uuid::Uuid,
750 include_groups: Option<bool>,
751 include_collections: Option<bool>,
752 ) -> Result<models::OrganizationUserUserDetailsResponseModelListResponseModel, Error> {
753 let local_var_configuration = &self.configuration;
754
755 let local_var_client = &local_var_configuration.client;
756
757 let local_var_uri_str = format!(
758 "{}/organizations/{orgId}/users",
759 local_var_configuration.base_path,
760 orgId = org_id
761 );
762 let mut local_var_req_builder =
763 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
764
765 if let Some(ref param_value) = include_groups {
766 local_var_req_builder =
767 local_var_req_builder.query(&[("includeGroups", ¶m_value.to_string())]);
768 }
769 if let Some(ref param_value) = include_collections {
770 local_var_req_builder =
771 local_var_req_builder.query(&[("includeCollections", ¶m_value.to_string())]);
772 }
773 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
774
775 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
776 }
777
778 async fn get_invite<'a>(
779 &self,
780 get_organization_invite_request_model: Option<models::GetOrganizationInviteRequestModel>,
781 ) -> Result<models::OrganizationInviteResponseModel, Error> {
782 let local_var_configuration = &self.configuration;
783
784 let local_var_client = &local_var_configuration.client;
785
786 let local_var_uri_str = format!(
787 "{}/organizations/users/invite-link/invite",
788 local_var_configuration.base_path
789 );
790 let mut local_var_req_builder =
791 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
792
793 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
794 local_var_req_builder = local_var_req_builder.json(&get_organization_invite_request_model);
795
796 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
797 }
798
799 async fn get_mini_details<'a>(
800 &self,
801 org_id: uuid::Uuid,
802 ) -> Result<models::OrganizationUserUserMiniDetailsResponseModelListResponseModel, Error> {
803 let local_var_configuration = &self.configuration;
804
805 let local_var_client = &local_var_configuration.client;
806
807 let local_var_uri_str = format!(
808 "{}/organizations/{orgId}/users/mini-details",
809 local_var_configuration.base_path,
810 orgId = org_id
811 );
812 let mut local_var_req_builder =
813 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
814
815 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
816
817 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
818 }
819
820 async fn get_pending_auto_confirm_users<'a>(
821 &self,
822 org_id: uuid::Uuid,
823 ) -> Result<models::OrganizationUserPendingAutoConfirmResponseModelListResponseModel, Error>
824 {
825 let local_var_configuration = &self.configuration;
826
827 let local_var_client = &local_var_configuration.client;
828
829 let local_var_uri_str = format!(
830 "{}/organizations/{orgId}/users/pending-auto-confirm",
831 local_var_configuration.base_path,
832 orgId = org_id
833 );
834 let mut local_var_req_builder =
835 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
836
837 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
838
839 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
840 }
841
842 async fn get_reset_password_details<'a>(
843 &self,
844 id: uuid::Uuid,
845 org_id: &'a str,
846 organization: Option<models::Organization>,
847 ) -> Result<models::OrganizationUserResetPasswordDetailsResponseModel, Error> {
848 let local_var_configuration = &self.configuration;
849
850 let local_var_client = &local_var_configuration.client;
851
852 let local_var_uri_str = format!(
853 "{}/organizations/{orgId}/users/{id}/reset-password-details",
854 local_var_configuration.base_path,
855 id = id,
856 orgId = crate::apis::urlencode(org_id)
857 );
858 let mut local_var_req_builder =
859 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
860
861 if let Some(ref param_value) = organization {
862 local_var_req_builder = local_var_req_builder
863 .query(&[("organization", &serde_json::to_value(param_value)?)]);
864 }
865 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
866
867 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
868 }
869
870 async fn invite<'a>(
871 &self,
872 org_id: uuid::Uuid,
873 organization_user_invite_request_model: Option<models::OrganizationUserInviteRequestModel>,
874 ) -> Result<(), Error> {
875 let local_var_configuration = &self.configuration;
876
877 let local_var_client = &local_var_configuration.client;
878
879 let local_var_uri_str = format!(
880 "{}/organizations/{orgId}/users/invite",
881 local_var_configuration.base_path,
882 orgId = org_id
883 );
884 let mut local_var_req_builder =
885 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
886
887 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
888 local_var_req_builder = local_var_req_builder.json(&organization_user_invite_request_model);
889
890 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
891 }
892
893 async fn put<'a>(
894 &self,
895 id: uuid::Uuid,
896 org_id: &'a str,
897 organization: Option<models::Organization>,
898 organization_user_update_request_model: Option<models::OrganizationUserUpdateRequestModel>,
899 ) -> Result<(), Error> {
900 let local_var_configuration = &self.configuration;
901
902 let local_var_client = &local_var_configuration.client;
903
904 let local_var_uri_str = format!(
905 "{}/organizations/{orgId}/users/{id}",
906 local_var_configuration.base_path,
907 id = id,
908 orgId = crate::apis::urlencode(org_id)
909 );
910 let mut local_var_req_builder =
911 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
912
913 if let Some(ref param_value) = organization {
914 local_var_req_builder = local_var_req_builder
915 .query(&[("organization", &serde_json::to_value(param_value)?)]);
916 }
917 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
918 local_var_req_builder = local_var_req_builder.json(&organization_user_update_request_model);
919
920 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
921 }
922
923 async fn put_reset_password_enrollment<'a>(
924 &self,
925 org_id: uuid::Uuid,
926 user_id: uuid::Uuid,
927 organization_user_reset_password_enrollment_request_model: Option<
928 models::OrganizationUserResetPasswordEnrollmentRequestModel,
929 >,
930 ) -> Result<(), Error> {
931 let local_var_configuration = &self.configuration;
932
933 let local_var_client = &local_var_configuration.client;
934
935 let local_var_uri_str = format!(
936 "{}/organizations/{orgId}/users/{userId}/reset-password-enrollment",
937 local_var_configuration.base_path,
938 orgId = org_id,
939 userId = user_id
940 );
941 let mut local_var_req_builder =
942 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
943
944 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
945 local_var_req_builder =
946 local_var_req_builder.json(&organization_user_reset_password_enrollment_request_model);
947
948 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
949 }
950
951 async fn recover_account<'a>(
952 &self,
953 org_id: uuid::Uuid,
954 id: uuid::Uuid,
955 target_organization_user: Option<models::OrganizationUser>,
956 organization_user_reset_password_request_model: Option<
957 models::OrganizationUserResetPasswordRequestModel,
958 >,
959 ) -> Result<(), Error> {
960 let local_var_configuration = &self.configuration;
961
962 let local_var_client = &local_var_configuration.client;
963
964 let local_var_uri_str = format!(
965 "{}/organizations/{orgId}/users/{id}/recover-account",
966 local_var_configuration.base_path,
967 orgId = org_id,
968 id = id
969 );
970 let mut local_var_req_builder =
971 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
972
973 if let Some(ref param_value) = target_organization_user {
974 local_var_req_builder = local_var_req_builder.query(&[(
975 "targetOrganizationUser",
976 &serde_json::to_value(param_value)?,
977 )]);
978 }
979 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
980 local_var_req_builder =
981 local_var_req_builder.json(&organization_user_reset_password_request_model);
982
983 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
984 }
985
986 async fn reinvite<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error> {
987 let local_var_configuration = &self.configuration;
988
989 let local_var_client = &local_var_configuration.client;
990
991 let local_var_uri_str = format!(
992 "{}/organizations/{orgId}/users/{id}/reinvite",
993 local_var_configuration.base_path,
994 orgId = org_id,
995 id = id
996 );
997 let mut local_var_req_builder =
998 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
999
1000 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1001
1002 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
1003 }
1004
1005 async fn remove<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error> {
1006 let local_var_configuration = &self.configuration;
1007
1008 let local_var_client = &local_var_configuration.client;
1009
1010 let local_var_uri_str = format!(
1011 "{}/organizations/{orgId}/users/{id}",
1012 local_var_configuration.base_path,
1013 orgId = org_id,
1014 id = id
1015 );
1016 let mut local_var_req_builder =
1017 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1018
1019 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1020
1021 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
1022 }
1023
1024 async fn restore_async_v_next<'a>(
1025 &self,
1026 org_id: uuid::Uuid,
1027 id: uuid::Uuid,
1028 organization_user_restore_request: Option<models::OrganizationUserRestoreRequest>,
1029 ) -> Result<(), Error> {
1030 let local_var_configuration = &self.configuration;
1031
1032 let local_var_client = &local_var_configuration.client;
1033
1034 let local_var_uri_str = format!(
1035 "{}/organizations/{orgId}/users/{id}/restore/vnext",
1036 local_var_configuration.base_path,
1037 orgId = org_id,
1038 id = id
1039 );
1040 let mut local_var_req_builder =
1041 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1042
1043 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1044 local_var_req_builder = local_var_req_builder.json(&organization_user_restore_request);
1045
1046 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
1047 }
1048
1049 async fn revoke<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error> {
1050 let local_var_configuration = &self.configuration;
1051
1052 let local_var_client = &local_var_configuration.client;
1053
1054 let local_var_uri_str = format!(
1055 "{}/organizations/{orgId}/users/{id}/revoke",
1056 local_var_configuration.base_path,
1057 orgId = org_id,
1058 id = id
1059 );
1060 let mut local_var_req_builder =
1061 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1062
1063 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1064
1065 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
1066 }
1067
1068 async fn revoke_self<'a>(&self, org_id: uuid::Uuid) -> Result<(), Error> {
1069 let local_var_configuration = &self.configuration;
1070
1071 let local_var_client = &local_var_configuration.client;
1072
1073 let local_var_uri_str = format!(
1074 "{}/organizations/{orgId}/users/revoke-self",
1075 local_var_configuration.base_path,
1076 orgId = org_id
1077 );
1078 let mut local_var_req_builder =
1079 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1080
1081 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1082
1083 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
1084 }
1085
1086 async fn send_invite_to_staged_users<'a>(
1088 &self,
1089 org_id: uuid::Uuid,
1090 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
1091 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
1092 let local_var_configuration = &self.configuration;
1093
1094 let local_var_client = &local_var_configuration.client;
1095
1096 let local_var_uri_str = format!(
1097 "{}/organizations/{orgId}/users/send-invite",
1098 local_var_configuration.base_path,
1099 orgId = org_id
1100 );
1101 let mut local_var_req_builder =
1102 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1103
1104 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1105 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
1106
1107 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
1108 }
1109
1110 async fn user_public_keys<'a>(
1111 &self,
1112 org_id: uuid::Uuid,
1113 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
1114 ) -> Result<models::OrganizationUserPublicKeyResponseModelListResponseModel, Error> {
1115 let local_var_configuration = &self.configuration;
1116
1117 let local_var_client = &local_var_configuration.client;
1118
1119 let local_var_uri_str = format!(
1120 "{}/organizations/{orgId}/users/public-keys",
1121 local_var_configuration.base_path,
1122 orgId = org_id
1123 );
1124 let mut local_var_req_builder =
1125 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1126
1127 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1128 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
1129
1130 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
1131 }
1132}